@azure/mcp-linux-arm64 2.0.0-beta.30 → 2.0.0-beta.31

package/dist/Instrumentation/Resources/api-reference/dotnet/AddApplicationInsightsTelemetryWorkerService.md

@@ -0,0 +1,115 @@
+---
+title: AddApplicationInsightsTelemetryWorkerService
+category: api-reference
+applies-to: 3.x
+source: NETCORE/src/Microsoft.ApplicationInsights.WorkerService/ApplicationInsightsExtensions.cs
+---
+
+# AddApplicationInsightsTelemetryWorkerService
+
+**Package:** `Microsoft.ApplicationInsights.WorkerService` (3.x)
+
+## Signatures
+
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+
+// 1. Parameterless — reads config from appsettings.json / env vars
+public static IServiceCollection AddApplicationInsightsTelemetryWorkerService(
+    this IServiceCollection services);
+
+// 2. IConfiguration — binds "ApplicationInsights" section
+public static IServiceCollection AddApplicationInsightsTelemetryWorkerService(
+    this IServiceCollection services,
+    IConfiguration configuration);
+
+// 3. Action delegate — configure options inline
+public static IServiceCollection AddApplicationInsightsTelemetryWorkerService(
+    this IServiceCollection services,
+    Action<ApplicationInsightsServiceOptions> options);
+
+// 4. Options instance — pass a pre-built options object
+public static IServiceCollection AddApplicationInsightsTelemetryWorkerService(
+    this IServiceCollection services,
+    ApplicationInsightsServiceOptions options);
+```
+
+All overloads return `IServiceCollection`. Overloads 2–4 call overload 1 internally, then apply configuration.
+
+## ApplicationInsightsServiceOptions
+
+Namespace: `Microsoft.ApplicationInsights.WorkerService`
+
+| Property | Type | Default | Description |
+|---|---|---|---|
+| `ConnectionString` | `string` | `null` | Connection string for Application Insights. Can also be set via env var or config (see below). |
+| `Credential` | `TokenCredential` | `null` | AAD credential for token-based authentication. When null, the instrumentation key from the connection string is used. |
+| `ApplicationVersion` | `string` | Entry assembly version | Application version reported with telemetry. |
+| `EnableQuickPulseMetricStream` | `bool` | `true` | Enables Live Metrics. |
+| `EnablePerformanceCounterCollectionModule` | `bool` | `true` | Enables performance counter collection. |
+| `EnableDependencyTrackingTelemetryModule` | `bool` | `true` | Enables HTTP and SQL dependency tracking. |
+| `AddAutoCollectedMetricExtractor` | `bool` | `true` | Enables standard metric extraction. |
+| `TracesPerSecond` | `double?` | `null` (effective: `5`) | Rate-limited sampling — targets this many traces per second. Must be ≥ 0. |
+| `SamplingRatio` | `float?` | `null` | Fixed-rate sampling (0.0–1.0, where 1.0 = no sampling). When set, overrides `TracesPerSecond`. |
+| `EnableTraceBasedLogsSampler` | `bool?` | `null` (effective: `true`) | When true, logs are sampled with their parent trace. Set `false` to collect all logs. |
+
+**Note:** Unlike the ASP.NET Core package, WorkerService does not include `EnableRequestTrackingTelemetryModule` or `EnableAuthenticationTrackingJavaScript`.
+
+## Minimal example
+
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+
+var builder = Host.CreateDefaultBuilder(args);
+builder.ConfigureServices(services =>
+{
+    services.AddApplicationInsightsTelemetryWorkerService();
+});
+var host = builder.Build();
+await host.RunAsync();
+```
+
+Set the connection string via environment variable:
+```
+APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=...;IngestionEndpoint=...
+```
+
+Or in `appsettings.json`:
+```json
+{
+  "ApplicationInsights": {
+    "ConnectionString": "InstrumentationKey=...;IngestionEndpoint=..."
+  }
+}
+```
+
+## Full example
+
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.ApplicationInsights.WorkerService;
+
+var builder = Host.CreateDefaultBuilder(args);
+builder.ConfigureServices(services =>
+{
+    services.AddApplicationInsightsTelemetryWorkerService(options =>
+    {
+        options.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+        options.EnableQuickPulseMetricStream = true;
+        options.SamplingRatio = 0.5f;    // Collect 50% of telemetry
+    });
+});
+var host = builder.Build();
+await host.RunAsync();
+```
+
+## Behavior notes
+
+- Connection string resolution order: `ApplicationInsightsServiceOptions.ConnectionString` → env var `APPLICATIONINSIGHTS_CONNECTION_STRING` → config key `ApplicationInsights:ConnectionString`.
+- `TracesPerSecond` is the default sampling mode (effective default `5`). Set `SamplingRatio` for fixed-rate sampling instead.
+- Additional OTel sources/meters can be added: `services.AddOpenTelemetry().WithTracing(t => t.AddSource("MySource"))`.
+## See also
+
+- UseAzureMonitor (distro)(see in UseAzureMonitor.md)
+- UseAzureMonitorExporter(see in UseAzureMonitorExporter.md)
+- Worker Service 2.x → 3.x Migration(see in workerservice-2x-to-3x-code-migration.md)

package/dist/Instrumentation/Resources/api-reference/dotnet/ApplicationInsightsWeb.md

@@ -0,0 +1,103 @@
+---
+title: ApplicationInsightsWeb
+category: api-reference
+applies-to: 3.x
+---
+
+# Microsoft.ApplicationInsights.Web — API Reference
+
+## Package
+
+```
+Microsoft.ApplicationInsights.Web
+```
+
+Target: .NET Framework 4.6.2+
+
+## ApplicationInsights.config elements
+
+| Element | Default | Description |
+|---|---|---|
+| `ConnectionString` | — | **Required.** Azure Monitor connection string. |
+| `DisableTelemetry` | `false` | Disable all telemetry collection. |
+| `ApplicationVersion` | — | Sets `service.version` resource attribute. |
+| `TracesPerSecond` | `5.0` | Rate-limited sampling (traces per second). |
+| `SamplingRatio` | — | Fixed-rate sampling (0.0–1.0). Overrides `TracesPerSecond` if set. |
+| `EnableTraceBasedLogsSampler` | `true` | Logs follow parent trace sampling decision. |
+| `StorageDirectory` | — | Directory for offline telemetry storage. |
+| `DisableOfflineStorage` | `false` | Disable offline storage. |
+| `EnableQuickPulseMetricStream` | `true` | Enable Live Metrics. |
+| `EnablePerformanceCounterCollectionModule` | `true` | Collect performance counters. |
+| `EnableDependencyTrackingTelemetryModule` | `true` | Track SQL/HTTP dependencies. |
+| `EnableRequestTrackingTelemetryModule` | `true` | Track incoming HTTP requests. |
+| `AddAutoCollectedMetricExtractor` | `true` | Extract standard metrics. |
+
+## Removed in 3.x (from 2.x)
+
+| Element/Section | Status |
+|---|---|
+| `<InstrumentationKey>` | **Removed** — use `<ConnectionString>` |
+| `<TelemetryInitializers>` | **Removed** — initializers are now internal Activity Processors |
+| `<TelemetryModules>` | **Removed** — modules are auto-configured internally |
+| `<TelemetryProcessors>` | **Removed** — use `ConfigureOpenTelemetryBuilder` for custom processors |
+| `<TelemetryChannel>` | **Removed** — export pipeline managed by OpenTelemetry |
+
+## HTTP modules required in Web.config
+
+### IIS Integrated mode (`system.webServer/modules`)
+
+```xml
+<add name="ApplicationInsightsWebTracking"
+     type="Microsoft.ApplicationInsights.Web.ApplicationInsightsHttpModule, Microsoft.AI.Web"
+     preCondition="managedHandler" />
+<add name="TelemetryHttpModule"
+     type="OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule, OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule"
+     preCondition="integratedMode,managedHandler" />
+```
+
+### IIS Classic mode (`system.web/httpModules`)
+
+```xml
+<add name="ApplicationInsightsWebTracking"
+     type="Microsoft.ApplicationInsights.Web.ApplicationInsightsHttpModule, Microsoft.AI.Web" />
+```
+
+> These are auto-configured by the NuGet package install.
+
+## TelemetryClient usage
+
+`TelemetryClient` works the same as in ASP.NET Core 3.x. See TelemetryClient.md for breaking changes.
+
+Key difference: in classic ASP.NET, create via `new TelemetryClient(TelemetryConfiguration.CreateDefault())` or let `ApplicationInsightsHttpModule` initialize the configuration first.
+
+```csharp
+var client = new TelemetryClient(TelemetryConfiguration.CreateDefault());
+client.TrackEvent("OrderCreated", new Dictionary<string, string> { ["OrderId"] = orderId });
+client.TrackMetric("ProcessingTime", elapsed);
+```
+
+## ConfigureOpenTelemetryBuilder
+
+The primary extensibility point in 3.x for classic ASP.NET. Add custom processors, exporters, or resource attributes:
+
+```csharp
+// In Global.asax.cs Application_Start()
+var config = TelemetryConfiguration.CreateDefault();
+config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+config.ConfigureOpenTelemetryBuilder(otel =>
+{
+    otel.WithTracing(tracing =>
+    {
+        tracing.AddProcessor<MyFilterProcessor>();
+        tracing.AddConsoleExporter();    // For debugging
+    });
+    otel.ConfigureResource(r => r.AddService("MyWebApp"));
+});
+```
+
+## Notes
+
+- The NuGet package install handles all configuration — no code changes needed for basic setup.
+- `TelemetryCorrelationHttpModule` is **not needed** in 3.x — OpenTelemetry handles correlation natively.
+- Connection string can be set in `ApplicationInsights.config`, in code, or via `APPLICATIONINSIGHTS_CONNECTION_STRING` environment variable.
+- **Non-DI:** Classic ASP.NET does not use `IServiceCollection`. Use `TelemetryConfiguration.ConfigureOpenTelemetryBuilder` for extensibility.

package/dist/Instrumentation/Resources/api-reference/dotnet/ConfigureOpenTelemetryProvider.md

@@ -111,6 +111,11 @@ Register instrumentation sources early in startup, then configure exporters
 separately:
 
 ```csharp
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Resources;
+
 var builder = WebApplication.CreateBuilder(args);
 
 // Register sources (could be in a different file or method)
@@ -130,12 +135,30 @@ var app = builder.Build();
 app.Run();
 ```
 
+## Example - setting cloud role name via ConfigureResource
+
+A common migration pattern: replace a custom `ITelemetryInitializer` that sets
+cloud role name with `ConfigureResource` + `AddService`:
+
+```csharp
+using OpenTelemetry.Resources; // Required for ResourceBuilder.AddService
+
+// Set cloud role name (replaces ITelemetryInitializer that set Context.Cloud.RoleName)
+builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
+    tracing.ConfigureResource(r => r.AddService(
+        serviceName: "MyService",
+        serviceInstanceId: Environment.MachineName)));
+```
+
 ## Example - library author registering sources
 
 A library can register its instrumentation without depending on the app's
 startup code:
 
 ```csharp
+using OpenTelemetry.Trace;
+using OpenTelemetry.Metrics;
+
 public static class MyLibraryExtensions
 {
     public static IServiceCollection AddMyLibrary(this IServiceCollection services)

package/dist/Instrumentation/Resources/api-reference/dotnet/ConsoleExporter.md

@@ -0,0 +1,47 @@
+---
+title: ConsoleExporter
+category: api-reference
+applies-to: 1.x
+---
+
+# Console Exporter
+
+Writes traces, metrics, and logs to the console (stdout). Useful for **local development and debugging only** — not for production.
+
+## Package
+
+```
+OpenTelemetry.Exporter.Console
+```
+
+## Setup
+
+```csharp
+using OpenTelemetry.Trace;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Logs;
+
+builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
+    tracing.AddConsoleExporter());
+
+builder.Services.ConfigureOpenTelemetryMeterProvider(metrics =>
+    metrics.AddConsoleExporter());
+
+builder.Services.ConfigureOpenTelemetryLoggerProvider(logging =>
+    logging.AddConsoleExporter());
+```
+
+## Options
+
+| Option | Default | Description |
+|---|---|---|
+| `Targets` | `Console` | `ConsoleExporterOutputTargets.Console` or `Debug` (writes to `System.Diagnostics.Debug`). |
+
+## Notes
+
+- **Development only** — do not use in production. Adds significant overhead.
+- Useful for verifying that spans, metrics, and log records are being generated correctly.
+- Console exporter works alongside Azure Monitor — both receive the same telemetry.
+- Each signal needs its own `AddConsoleExporter()` call.
+- For production multi-destination export, use OTLP exporter instead.
+- **Non-DI usage:** Use `config.ConfigureOpenTelemetryBuilder(otel => otel.WithTracing(t => t.AddConsoleExporter()))` on `TelemetryConfiguration`. See TelemetryClient.md.

package/dist/Instrumentation/Resources/api-reference/dotnet/EntityFrameworkInstrumentation.md

@@ -0,0 +1,56 @@
+---
+title: EntityFrameworkInstrumentation
+category: api-reference
+applies-to: 1.x
+---
+
+# Entity Framework Core Instrumentation
+
+## Package
+
+```
+OpenTelemetry.Instrumentation.EntityFrameworkCore
+```
+
+## Setup
+
+```csharp
+using OpenTelemetry.Trace;
+
+// EF Core is auto-instrumented via DiagnosticSource — no additional setup needed.
+// To customize, use ConfigureOpenTelemetryTracerProvider:
+builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
+    tracing.AddEntityFrameworkCoreInstrumentation(options =>
+    {
+        options.SetDbStatementForText = true;  // Include SQL text (be careful with PII)
+        options.SetDbStatementForStoredProcedure = true;
+    }));
+```
+
+## Options
+
+| Option | Default | Description |
+|---|---|---|
+| `SetDbStatementForText` | `false` | Include raw SQL text in `db.statement` attribute. May contain PII. |
+| `SetDbStatementForStoredProcedure` | `true` | Include stored procedure names in `db.statement`. |
+| `EnrichWithIDbCommand` | `null` | `Action<Activity, IDbCommand>` callback to enrich spans with custom tags from the command. |
+| `Filter` | `null` | `Func<string, string, bool>` — filter by provider name and command text. Return `false` to suppress. |
+
+## Semantic conventions
+
+EF Core spans use the [OpenTelemetry Database semantic conventions](https://opentelemetry.io/docs/specs/semconv/database/):
+
+| Attribute | Example |
+|---|---|
+| `db.system` | `microsoft.sql_server`, `postgresql`, `sqlite` |
+| `db.name` | `MyDatabase` |
+| `db.statement` | `SELECT * FROM Orders WHERE Id = @p0` (if `SetDbStatementForText = true`) |
+| `server.address` | `localhost` |
+| `server.port` | `5432` |
+
+## Notes
+
+- EF Core instrumentation relies on `DiagnosticSource` events emitted by EF Core itself — no additional packages needed for basic span collection.
+- The `OpenTelemetry.Instrumentation.EntityFrameworkCore` package is only needed to customize options (SQL text capture, enrichment, filtering).
+- Works with all EF Core providers (SQL Server, PostgreSQL, SQLite, MySQL, etc.).
+- **Non-DI usage:** If not using ASP.NET Core DI, use `config.ConfigureOpenTelemetryBuilder(otel => otel.WithTracing(t => t.AddEntityFrameworkCoreInstrumentation()))` on `TelemetryConfiguration`. See TelemetryClient.md.

package/dist/Instrumentation/Resources/api-reference/dotnet/HttpInstrumentation.md

@@ -0,0 +1,109 @@
+---
+title: HttpInstrumentation
+category: api-reference
+applies-to: 1.x
+---
+
+# HTTP Instrumentation — Client & Server Enrichment
+
+HTTP client and server instrumentation is auto-configured by both Azure Monitor Distro and Application Insights 3.x. This doc covers **customization**: enrichment, filtering, and advanced options.
+
+## Packages
+
+| Scope | Package | Auto-included? |
+|---|---|---|
+| HTTP Client (`HttpClient`) | `OpenTelemetry.Instrumentation.Http` | Yes (by Distro & AI 3.x) |
+| HTTP Server (ASP.NET Core) | `OpenTelemetry.Instrumentation.AspNetCore` | Yes (by Distro & AI 3.x) |
+
+You only need to install these packages explicitly if you want to **customize** the instrumentation options.
+
+## HTTP Client enrichment
+
+```csharp
+using OpenTelemetry.Trace;
+
+builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
+    tracing.AddHttpClientInstrumentation(options =>
+    {
+        options.EnrichWithHttpRequestMessage = (activity, request) =>
+        {
+            activity.SetTag("http.request.header.x-correlation-id",
+                request.Headers.TryGetValues("X-Correlation-Id", out var vals) ? vals.First() : null);
+        };
+        options.EnrichWithHttpResponseMessage = (activity, response) =>
+        {
+            activity.SetTag("http.response.content_length", response.Content.Headers.ContentLength);
+        };
+        options.FilterHttpRequestMessage = (request) =>
+        {
+            // Suppress health check calls
+            return request.RequestUri?.AbsolutePath != "/health";
+        };
+        options.RecordException = true;
+    }));
+```
+
+## HTTP Client options
+
+| Option | Default | Description |
+|---|---|---|
+| `EnrichWithHttpRequestMessage` | `null` | `Action<Activity, HttpRequestMessage>` to add tags from the request. |
+| `EnrichWithHttpResponseMessage` | `null` | `Action<Activity, HttpResponseMessage>` to add tags from the response. |
+| `EnrichWithException` | `null` | `Action<Activity, Exception>` to enrich on failure. |
+| `FilterHttpRequestMessage` | `null` | `Func<HttpRequestMessage, bool>` — return `false` to suppress span. |
+| `RecordException` | `false` | Record exception events on the span. |
+
+## HTTP Server (ASP.NET Core) enrichment
+
+```csharp
+using OpenTelemetry.Trace;
+
+builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
+    tracing.AddAspNetCoreInstrumentation(options =>
+    {
+        options.EnrichWithHttpRequest = (activity, request) =>
+        {
+            activity.SetTag("http.request.header.user-agent", request.Headers["User-Agent"].ToString());
+        };
+        options.EnrichWithHttpResponse = (activity, response) =>
+        {
+            activity.SetTag("http.response.custom_header", response.Headers["X-Custom"].ToString());
+        };
+        options.Filter = (httpContext) =>
+        {
+            // Suppress /health and /metrics endpoints
+            return httpContext.Request.Path != "/health"
+                && httpContext.Request.Path != "/metrics";
+        };
+        options.RecordException = true;
+    }));
+```
+
+## HTTP Server options
+
+| Option | Default | Description |
+|---|---|---|
+| `EnrichWithHttpRequest` | `null` | `Action<Activity, HttpRequest>` to add tags from the request. |
+| `EnrichWithHttpResponse` | `null` | `Action<Activity, HttpResponse>` to add tags from the response. |
+| `EnrichWithException` | `null` | `Action<Activity, Exception>` to enrich on failure. |
+| `Filter` | `null` | `Func<HttpContext, bool>` — return `false` to suppress span. |
+| `RecordException` | `false` | Record exception events on the span. |
+
+## Semantic conventions (auto-populated)
+
+| Attribute | Source |
+|---|---|
+| `http.request.method` | `GET`, `POST`, etc. |
+| `url.full` | Full URL (client) |
+| `url.path` | Path (server) |
+| `http.response.status_code` | `200`, `404`, etc. |
+| `server.address` | Target host (client) |
+| `network.protocol.version` | `1.1`, `2` |
+| `http.route` | Route template (server) |
+
+## Notes
+
+- Both client and server instrumentation are **already active** in AI 3.x setups. Adding the packages explicitly is only needed to access the `options` overload for enrichment/filtering.
+- Enrichment callbacks run synchronously on the hot path — keep them lightweight.
+- `Filter` on the server side is the recommended way to suppress health check / readiness probe spans (instead of a custom processor).
+- **Non-DI usage:** Use `config.ConfigureOpenTelemetryBuilder(otel => otel.WithTracing(t => t.AddHttpClientInstrumentation(...)))` on `TelemetryConfiguration`. See TelemetryClient.md.

package/dist/Instrumentation/Resources/api-reference/dotnet/LogProcessors.md

@@ -15,6 +15,8 @@ applies-to: 1.x
 ## Filtering — use `AddFilter`
 
 ```csharp
+using OpenTelemetry.Logs; // Required for OpenTelemetryLoggerProvider
+
 builder.Logging.AddFilter<OpenTelemetryLoggerProvider>("Microsoft.AspNetCore", LogLevel.Warning);
 builder.Logging.AddFilter<OpenTelemetryLoggerProvider>("System.Net.Http", LogLevel.Warning);
 ```

package/dist/Instrumentation/Resources/api-reference/dotnet/OtlpExporter.md

@@ -0,0 +1,88 @@
+---
+title: OtlpExporter
+category: api-reference
+applies-to: 1.x
+---
+
+# OTLP Exporter
+
+Export traces, metrics, and logs to any OpenTelemetry Protocol (OTLP) compatible backend (e.g. Jaeger, Grafana Tempo, Aspire Dashboard, custom collectors).
+
+## Package
+
+```
+OpenTelemetry.Exporter.OpenTelemetryProtocol
+```
+
+## Setup
+
+```csharp
+using OpenTelemetry.Trace;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Logs;
+using OpenTelemetry.Exporter;
+
+// Azure Monitor is already configured via AddApplicationInsightsTelemetry.
+// Add OTLP as a secondary exporter:
+builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
+    tracing.AddOtlpExporter(options =>
+    {
+        options.Endpoint = new Uri("http://localhost:4317");
+        options.Protocol = OtlpExportProtocol.Grpc;
+    }));
+
+builder.Services.ConfigureOpenTelemetryMeterProvider(metrics =>
+    metrics.AddOtlpExporter(options =>
+    {
+        options.Endpoint = new Uri("http://localhost:4317");
+    }));
+
+builder.Services.ConfigureOpenTelemetryLoggerProvider(logging =>
+    logging.AddOtlpExporter(options =>
+    {
+        options.Endpoint = new Uri("http://localhost:4317");
+    }));
+```
+    .WithTracing(tracing => tracing.AddOtlpExporter())
+    .WithMetrics(metrics => metrics.AddOtlpExporter());
+```
+
+### Environment variable configuration
+
+Instead of code, configure via environment variables:
+
+| Variable | Default | Description |
+|---|---|---|
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://localhost:4317` | OTLP endpoint URL |
+| `OTEL_EXPORTER_OTLP_PROTOCOL` | `grpc` | Protocol: `grpc` or `http/protobuf` |
+| `OTEL_EXPORTER_OTLP_HEADERS` | — | Headers as `key=value` pairs, comma-separated |
+| `OTEL_EXPORTER_OTLP_TIMEOUT` | `10000` | Timeout in milliseconds |
+
+## Options
+
+| Option | Default | Description |
+|---|---|---|
+| `Endpoint` | `http://localhost:4317` | Backend URL. Use port `4317` for gRPC, `4318` for HTTP. |
+| `Protocol` | `Grpc` | `OtlpExportProtocol.Grpc` or `OtlpExportProtocol.HttpProtobuf` |
+| `Headers` | `null` | Custom headers (e.g. auth tokens). Format: `"key=value"` |
+| `TimeoutMilliseconds` | `10000` | Export timeout. |
+| `ExportProcessorType` | `Batch` | `Batch` or `Simple`. Use `Simple` for debugging only. |
+| `BatchExportProcessorOptions` | default | Batch size, delay, queue size for batch processor. |
+
+## Common backends
+
+| Backend | Endpoint | Protocol |
+|---|---|---|
+| Aspire Dashboard | `http://localhost:4317` | gRPC |
+| Jaeger | `http://localhost:4317` | gRPC |
+| Grafana Tempo | `http://localhost:4317` | gRPC |
+| Grafana Cloud | `https://otlp-gateway-*.grafana.net/otlp` | HTTP (`http/protobuf`) |
+| Seq | `http://localhost:5341/ingest/otlp/v1/traces` | HTTP |
+
+## Notes
+
+- OTLP exporter works **alongside** Azure Monitor — data is sent to both destinations.
+- For local development with Aspire Dashboard, use `http://localhost:4317` with gRPC.
+- `AddOtlpExporter()` with no arguments uses environment variables or defaults.
+- Each signal (traces, metrics, logs) needs its own `AddOtlpExporter()` call.
+- **Non-DI usage:** Use `config.ConfigureOpenTelemetryBuilder(otel => otel.WithTracing(t => t.AddOtlpExporter(...)))` on `TelemetryConfiguration`. See TelemetryClient.md.

package/dist/Instrumentation/Resources/api-reference/dotnet/RedisInstrumentation.md

@@ -0,0 +1,63 @@
+---
+title: RedisInstrumentation
+category: api-reference
+applies-to: 1.x
+---
+
+# Redis Instrumentation (StackExchange.Redis)
+
+## Package
+
+```
+OpenTelemetry.Instrumentation.StackExchangeRedis
+```
+
+## Setup
+
+```csharp
+using OpenTelemetry.Trace;
+using OpenTelemetry.Instrumentation.StackExchangeRedis;
+
+// Register IConnectionMultiplexer in DI
+builder.Services.AddSingleton<IConnectionMultiplexer>(
+    ConnectionMultiplexer.Connect("localhost:6379"));
+
+// Add Redis instrumentation
+builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
+    tracing.AddRedisInstrumentation());
+```
+
+## Options with customization
+
+```csharp
+builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
+    tracing.AddRedisInstrumentation(options =>
+    {
+        options.SetVerboseDatabaseStatements = true;
+    }));
+```
+
+## Options
+
+| Option | Default | Description |
+|---|---|---|
+| `SetVerboseDatabaseStatements` | `false` | Include full Redis command in `db.statement` (e.g. `GET mykey`). |
+| `EnrichActivityWithTimingEvents` | `true` | Add Redis timing events (enqueue, sent, response) as Activity events. |
+| `Enrich` | `null` | `Action<Activity, IProfiledCommand>` callback to add custom tags. |
+| `FlushInterval` | 1 second | How often to flush profiling sessions. |
+
+## Semantic conventions
+
+| Attribute | Example |
+|---|---|
+| `db.system` | `redis` |
+| `db.statement` | `GET mykey` (if verbose) |
+| `server.address` | `localhost` |
+| `server.port` | `6379` |
+| `db.redis.database_index` | `0` |
+
+## Notes
+
+- The Redis instrumentation hooks into `StackExchange.Redis` profiling. It requires either DI-registered `IConnectionMultiplexer` (auto-discovered) or passing the connection explicitly.
+- When using DI registration, the instrumentation automatically discovers all `IConnectionMultiplexer` instances — no need to pass the connection manually.
+- **Non-DI usage:** Use `config.ConfigureOpenTelemetryBuilder(otel => otel.WithTracing(t => t.AddRedisInstrumentation(connection)))` on `TelemetryConfiguration`. See TelemetryClient.md.