@azure/mcp-linux-arm64 2.0.0-beta.27 → 2.0.0-beta.28

package/README.md

@@ -96,10 +96,6 @@ Check out the remote hosting [azd templates](https://github.com/microsoft/mcp/bl
 * List Microsoft Foundry agents
 * Connect and query Microsoft Foundry agents
 * Evaluate Microsoft Foundry agents
-* Get SDK samples for interacting with Microsoft Foundry agent
-* Create Microsoft Foundry agent threads
-* List Microsoft Foundry agent threads
-* Get messages of a Microsoft Foundry thread
 
 ### 📊 Azure Advisor
 
@@ -276,6 +272,14 @@ Example prompts that generate Azure CLI commands:
 
 * "Query my Log Analytics workspace"
 
+### 🧭 Azure Monitor Instrumentation
+
+* "List available Azure Monitor onboarding learning resources"
+* "Get the learning resource at 'concepts/dotnet/opentelemetry-pipeline.md'"
+* "Start Azure Monitor instrumentation orchestration for my local workspace"
+* "Continue to the next orchestration step after I complete the previous action"
+* "Send brownfield analysis findings to continue migration planning"
+
 ### 🔧 Azure Resource Management
 
 * "List my resource groups"
@@ -315,9 +319,9 @@ Example prompts that generate Azure CLI commands:
 
 ### 🏛️ Azure Well-Architected Framework
 
+* "List all services with Well-Architected Framework guidance"
+* "What services have architectural guidance?"
 * "Get Well-Architected Framework guidance for App Service"
-* "What's the WAF guidance for a VM?"
-* "Show me the best practices for virtual machines"
 * "What's the architectural guidance for Azure Cosmos DB?"
 
 ## Complete List of Supported Azure Services
@@ -353,6 +357,7 @@ The Azure MCP Server provides tools for interacting with **43+ Azure service are
 - 🏪 **Azure Marketplace** - Product discovery
 - 🔄 **Azure Migrate** - Platform Landing Zone generation and modification guidance
 - 📈 **Azure Monitor** - Logging, metrics, and health monitoring
+- 🧭 **Azure Monitor Instrumentation** - Deterministic onboarding and migration workflow for instrumenting local applications
 - ⚖️ **Azure Policy** - Policies set to enforce organizational standards
 - ⚙️ **Azure Native ISV Services** - Third-party integrations
 - 🛡️ **Azure Quick Review CLI** - Compliance scanning

package/dist/Resources/api-reference/dotnet/ActivityProcessors.md

@@ -0,0 +1,119 @@
+---
+title: ActivityProcessors
+category: api-reference
+applies-to: 1.x
+---
+
+# Activity Processors — Filtering & Enrichment
+
+## Key concepts
+
+- Subclass `BaseProcessor<Activity>` to create a custom processor.
+- **`OnStart`** = enrichment (add tags early). **`OnEnd`** = filtering (all data finalized).
+- Register via `.AddProcessor<T>()` — see WithTracing.md.
+
+## Filtering — drop spans
+
+Clear the `Recorded` flag to prevent export. Export processors (`BatchActivityExportProcessor`, `SimpleActivityExportProcessor`) check `Activity.Recorded` and skip when `false`.
+
+```csharp
+using System.Diagnostics;
+using OpenTelemetry;
+
+public class HealthCheckFilterProcessor : BaseProcessor<Activity>
+{
+    private static readonly HashSet<string> SuppressedPaths = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "/health", "/ready", "/healthz", "/liveness"
+    };
+
+    public override void OnEnd(Activity data)
+    {
+        var path = data.GetTagItem("url.path")?.ToString()
+                ?? data.GetTagItem("http.route")?.ToString();
+
+        if (path != null && SuppressedPaths.Contains(path))
+        {
+            data.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded;
+        }
+    }
+}
+```
+
+> **Important:** Do not rely on skipping `base.OnEnd()` — `CompositeProcessor` iterates all processors regardless. The `Recorded` flag is the correct filtering mechanism.
+
+## Enrichment — add tags
+
+Use `OnStart` to attach tags before the span completes:
+
+```csharp
+using System.Diagnostics;
+using OpenTelemetry;
+
+public class EnrichmentProcessor : BaseProcessor<Activity>
+{
+    public override void OnStart(Activity data)
+    {
+        data.SetTag("deployment.environment", "production");
+        data.SetTag("cloud.region", "eastus");
+    }
+}
+```
+
+## Inspectable `Activity` properties
+
+`DisplayName`, `Source.Name`, `Kind`, `Status`, `Duration`, `Tags` (via `GetTagItem()`), `Events`, `Links`, `ParentId`.
+
+## Migration from Application Insights 2.x
+
+> **Key difference:** A single `ITelemetryInitializer` or `ITelemetryProcessor` handled all signal types (requests, dependencies, traces, events). In OpenTelemetry, traces, logs, and metrics are separate pipelines — each processor only sees its own signal. If the old initializer/processor touched both signals (e.g., checked for `RequestTelemetry` and `TraceTelemetry`), you need two OpenTelemetry processors: `BaseProcessor<Activity>` for traces + `BaseProcessor<LogRecord>` for logs. If it only touched trace types (`RequestTelemetry`, `DependencyTelemetry`), a single `BaseProcessor<Activity>` is sufficient. Any `if (telemetry is MetricTelemetry) return;` guards can be removed — metrics have their own pipeline and never reach activity or log processors.
+
+| 2.x Pattern | 3.x Equivalent |
+| --- | --- |
+| `ITelemetryInitializer.Initialize(ITelemetry)` | `BaseProcessor<Activity>.OnStart(Activity)` — enrich traces |
+| `ITelemetryInitializer` touching `TraceTelemetry`/`EventTelemetry` | `BaseProcessor<LogRecord>.OnEnd(LogRecord)` — enrich logs (see LogProcessors.md) |
+| `ITelemetryProcessor.Process(ITelemetry)` | `BaseProcessor<Activity>.OnEnd(Activity)` — filter traces |
+| `ITelemetryProcessor` filtering `TraceTelemetry` by severity | `ILoggingBuilder.AddFilter<OpenTelemetryLoggerProvider>()` — filter logs (see LogProcessors.md) |
+| `services.AddApplicationInsightsTelemetryProcessor<T>()` | `.AddProcessor<T>()` on `TracerProviderBuilder` |
+| Not calling `next.Process(item)` to drop | `data.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded;` |
+
+### Property mapping
+
+| 2.x Property | Activity equivalent | LogRecord equivalent |
+| --- | --- | --- |
+| `telemetry.Context.GlobalProperties["key"]` | `data.SetTag("key", value)` | Add to `data.Attributes` |
+| `telemetry.Properties["key"]` | `data.SetTag("key", value)` | Add to `data.Attributes` |
+| `request.Url.AbsolutePath` | `data.GetTagItem("url.path")` | N/A |
+| `request.ResponseCode` / `dependency.ResultCode` | `data.GetTagItem("http.response.status_code")` | N/A |
+| `request.Success = false` | `data.SetStatus(ActivityStatusCode.Error)` | N/A |
+| `request.Name` / `dependency.Name` | `data.DisplayName` (get/set) | N/A |
+| `dependency.Type` | `data.GetTagItem("db.system")` or `data.GetTagItem("rpc.system")` | N/A |
+| `dependency.Target` | `data.GetTagItem("server.address")` | N/A |
+| `dependency.Duration` | `data.Duration` | N/A |
+| `trace.SeverityLevel` | N/A | `data.LogLevel` |
+| `trace.Message` | N/A | `data.FormattedMessage` or `data.Attributes` |
+| `telemetry.Context.User.AuthenticatedUserId` | `data.SetTag("enduser.id", value)` | N/A |
+| `telemetry.Context.Operation.Id` | `data.TraceId` (read-only, set by framework) | `data.TraceId` |
+| `telemetry.Context.Cloud.RoleName` | Not a processor concern — use `ConfigureResource(r => r.AddService("name"))` | Same |
+
+### Telemetry type mapping
+
+Old processors often check `if (telemetry is RequestTelemetry)` or `if (telemetry is DependencyTelemetry)`. In 3.x, check `Activity.Kind`:
+
+| `ActivityKind` | Application Insights telemetry type |
+| --- | --- |
+| `Server` | `RequestTelemetry` |
+| `Consumer` | `RequestTelemetry` (message-driven) or `DependencyTelemetry` (when acting as downstream call) |
+| `Client` | `DependencyTelemetry` |
+| `Producer` | `DependencyTelemetry` |
+| `Internal` | `DependencyTelemetry` (if parent is `Server`/`Consumer`) |
+
+Other signal types:
+
+| Source | Application Insights telemetry type |
+| --- | --- |
+| `ILogger` logs | `TraceTelemetry` |
+| `ILogger` logs with `microsoft.custom_event.name` attribute | `EventTelemetry` |
+| Exceptions logged via `ILogger.LogError` / `LogCritical` | `ExceptionTelemetry` — now a `LogRecord` with exception attributes |
+| Exceptions on spans | `ExceptionTelemetry` — now an `Activity.Event` named `exception` (check `data.Events`) |
+| `Meter` measurements | `MetricTelemetry` |

package/dist/Resources/api-reference/dotnet/AddApplicationInsightsTelemetry.md

@@ -0,0 +1,129 @@
+---
+title: AddApplicationInsightsTelemetry
+category: api-reference
+applies-to: 3.x
+source: NETCORE/src/Microsoft.ApplicationInsights.AspNetCore/Extensions/ApplicationInsightsExtensions.cs
+---
+
+# AddApplicationInsightsTelemetry
+
+**Package:** `Microsoft.ApplicationInsights.AspNetCore` (3.x)
+
+## Signatures
+
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+
+// 1. Parameterless — reads config from appsettings.json / env vars
+public static IServiceCollection AddApplicationInsightsTelemetry(
+    this IServiceCollection services);
+
+// 2. IConfiguration — binds "ApplicationInsights" section
+public static IServiceCollection AddApplicationInsightsTelemetry(
+    this IServiceCollection services,
+    IConfiguration configuration);
+
+// 3. Action delegate — configure options inline
+public static IServiceCollection AddApplicationInsightsTelemetry(
+    this IServiceCollection services,
+    Action<ApplicationInsightsServiceOptions> options);
+
+// 4. Options instance — pass a pre-built options object
+public static IServiceCollection AddApplicationInsightsTelemetry(
+    this IServiceCollection services,
+    ApplicationInsightsServiceOptions options);
+```
+
+All overloads return `IServiceCollection`. Overloads 2–4 call overload 1 internally, then apply configuration.
+
+## ApplicationInsightsServiceOptions
+
+Namespace: `Microsoft.ApplicationInsights.AspNetCore.Extensions`
+
+| 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. |
+| `EnableRequestTrackingTelemetryModule` | `bool` | `true` | Enables ASP.NET Core request 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. |
+| `EnableAuthenticationTrackingJavaScript` | `bool` | `false` | Injects authenticated user tracking in the JavaScript snippet. ASP.NET Core only. |
+
+## JavaScriptSnippet
+
+Automatically registered as a singleton (`IJavaScriptSnippet` and `JavaScriptSnippet`) when `AddApplicationInsightsTelemetry()` is called.
+
+### Razor usage
+
+```cshtml
+@inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet
+
+<!-- FullScript includes <script> tags -->
+@Html.Raw(JavaScriptSnippet.FullScript)
+
+<!-- ScriptBody returns JS only (no <script> tags) — use inside your own script block -->
+<script>
+    @Html.Raw(JavaScriptSnippet.ScriptBody)
+</script>
+```
+
+- `FullScript` — complete `<script>` block ready to drop into a layout page. Return `string.Empty` when telemetry is disabled or connection string is not set.
+- `ScriptBody` — JavaScript only, for use inside an existing `<script>` tag.
+
+## Minimal example
+
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddApplicationInsightsTelemetry();
+var app = builder.Build();
+```
+
+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.AspNetCore.Extensions;
+
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddApplicationInsightsTelemetry(options =>
+{
+    options.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+    options.EnableQuickPulseMetricStream = true;
+    options.SamplingRatio = 0.5f;    // Collect 50% of telemetry
+    options.EnableAuthenticationTrackingJavaScript = true;
+});
+var app = builder.Build();
+```
+
+## 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: `builder.Services.AddOpenTelemetry().WithTracing(t => t.AddSource("MySource"))`.
+## See also
+
+- UseAzureMonitor (distro)(see in UseAzureMonitor.md)
+- UseAzureMonitorExporter(see in UseAzureMonitorExporter.md)
+- App Insights 2.x → 3.x Migration(see in appinsights-2x-to-3x-code-migration.md)

package/dist/Resources/api-reference/dotnet/AddOpenTelemetry.md

@@ -0,0 +1,153 @@
+---
+title: AddOpenTelemetry
+category: api-reference
+applies-to: 3.x
+---
+
+# services.AddOpenTelemetry()
+
+> [!NOTE]
+> This is the recommended approach for any application using the .NET Generic
+> Host (ASP.NET Core, Worker Services, MAUI, etc.).
+
+## When to use
+
+- **ASP.NET Core** web apps and APIs.
+- **Worker services** (`BackgroundService` / `IHostedService`).
+- Any application that already calls `Host.CreateDefaultBuilder()` or
+  `WebApplication.CreateBuilder()`.
+- Production services where you want **automatic lifecycle management** - no
+  manual `Dispose()` calls.
+
+## Minimal example
+
+```csharp
+using OpenTelemetry.Trace;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenTelemetry()
+    .ConfigureResource(r => r.AddService("my-web-api"))
+    .WithTracing(tracing => tracing
+        .AddAspNetCoreInstrumentation()
+        .AddConsoleExporter());
+
+var app = builder.Build();
+app.MapGet("/", () => "Hello World");
+app.Run();
+```
+
+## Full multi-signal example
+
+```csharp
+using OpenTelemetry.Logs;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Trace;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Clear default log providers if you want OTel to be the sole log sink
+builder.Logging.ClearProviders();
+
+builder.Services.AddOpenTelemetry()
+    .ConfigureResource(r => r
+        .AddService(
+            serviceName: "my-web-api",
+            serviceVersion: "1.0.0"))
+    .WithTracing(tracing => tracing
+        .AddAspNetCoreInstrumentation()
+        .AddHttpClientInstrumentation()
+        .AddSource("MyApp")
+        .AddOtlpExporter())
+    .WithMetrics(metrics => metrics
+        .AddAspNetCoreInstrumentation()
+        .AddHttpClientInstrumentation()
+        .AddMeter("MyApp")
+        .AddOtlpExporter())
+    .WithLogging(logging => logging
+        .AddOtlpExporter());
+
+var app = builder.Build();
+app.MapGet("/", () => "Hello World");
+app.Run();
+```
+
+## Worker service example
+
+```csharp
+using OpenTelemetry.Trace;
+
+var builder = Host.CreateApplicationBuilder(args);
+
+builder.Services.AddOpenTelemetry()
+    .ConfigureResource(r => r.AddService("my-worker"))
+    .WithTracing(tracing => tracing
+        .AddSource("MyWorker")
+        .AddOtlpExporter());
+
+builder.Services.AddHostedService<MyWorker>();
+
+var host = builder.Build();
+host.Run();
+```
+
+## API surface
+
+`AddOpenTelemetry()` returns an `OpenTelemetryBuilder` that implements
+`IOpenTelemetryBuilder`:
+
+| Method | Purpose |
+| --- | --- |
+| `.WithTracing(Action<TracerProviderBuilder>)` | Configure tracing |
+| `.WithMetrics(Action<MeterProviderBuilder>)` | Configure metrics |
+| `.WithLogging(Action<LoggerProviderBuilder>)` | Configure logging |
+| `.ConfigureResource(Action<ResourceBuilder>)` | Set resource attributes (shared across all signals) |
+
+## Lifecycle
+
+- **Host-managed.** The host starts the SDK via an `IHostedService` and
+  disposes it on graceful shutdown. You do **not** call `Dispose()` yourself.
+- **Safe to call multiple times.** Calling `AddOpenTelemetry()` from multiple
+  libraries or configuration modules is safe - only one `TracerProvider` and
+  one `MeterProvider` are created per `IServiceCollection`.
+- **DI-integrated.** Processors, exporters, and any custom services registered
+  in the DI container are available to the SDK. You can inject
+  `TracerProvider`, `MeterProvider`, or `ILoggerFactory` anywhere via
+  constructor injection.
+
+## Dependency injection tips
+
+### Accessing the TracerProvider
+
+```csharp
+app.MapGet("/trace-id", (TracerProvider tp) =>
+{
+    // TracerProvider is available via DI
+    return Activity.Current?.TraceId.ToString() ?? "none";
+});
+```
+
+### Registering a custom processor
+
+```csharp
+builder.Services.AddOpenTelemetry()
+    .WithTracing(tracing => tracing
+        .AddProcessor<MyFilteringProcessor>());  // resolved from DI
+
+builder.Services.AddSingleton<MyFilteringProcessor>();
+```
+
+## Comparison with the non-hosted builders
+
+| Concern | `AddOpenTelemetry()` | `OpenTelemetrySdk.Create()` |
+| --- | --- | --- |
+| Requires Generic Host | Yes | No |
+| Lifecycle | Automatic (host) | Manual (`Dispose()`) |
+| DI container | App's container | SDK-internal container |
+| Safe to call multiple times | Yes | N/A (single call) |
+| Builder API | Same `IOpenTelemetryBuilder` | Same `IOpenTelemetryBuilder` |
+
+> [!TIP]
+> **No host?** Use
+> `OpenTelemetrySdk.Create()`(see in OpenTelemetrySdkCreate.md) for the same
+> builder API with manual lifecycle control.

package/dist/Resources/api-reference/dotnet/AzureMonitorExporter.md

@@ -0,0 +1,137 @@
+---
+title: AzureMonitorExporter
+category: api-reference
+applies-to: 3.x
+source: src/AzureMonitorExporterExtensions.cs, src/AzureMonitorExporterOptions.cs
+---
+
+# AddAzureMonitor*Exporter
+
+**Namespace:** `Azure.Monitor.OpenTelemetry.Exporter`
+
+## When to use
+
+- You are building a **console app, CLI tool, or background job** without the .NET Generic Host.
+- You need to export **only a subset** of signals (e.g., traces and metrics but not logs).
+- You need **different options per signal** (e.g., different credentials or storage directories).
+
+## Signatures
+
+```csharp
+public static TracerProviderBuilder AddAzureMonitorTraceExporter(
+    this TracerProviderBuilder builder,
+    Action<AzureMonitorExporterOptions>? configure = null,
+    TokenCredential? credential = null,
+    string? name = null);
+
+public static MeterProviderBuilder AddAzureMonitorMetricExporter(
+    this MeterProviderBuilder builder,
+    Action<AzureMonitorExporterOptions>? configure = null,
+    TokenCredential? credential = null,
+    string? name = null);
+
+public static LoggerProviderBuilder AddAzureMonitorLogExporter(
+    this LoggerProviderBuilder builder,
+    Action<AzureMonitorExporterOptions>? configure = null,
+    TokenCredential? credential = null,
+    string? name = null);
+```
+
+A legacy overload extending `OpenTelemetryLoggerOptions` also exists but is superseded by the `LoggerProviderBuilder` version above.
+
+## Behavior notes
+
+- **Cannot** be combined with `UseAzureMonitorExporter` in the same app — a runtime exception is thrown.
+- **Live Metrics** is not supported by per-signal methods. Setting `EnableLiveMetrics = true` has no effect — a warning is logged and the setting is ignored.
+- For hosted apps (ASP.NET Core, Worker Services), prefer `UseAzureMonitorExporter()`(see in UseAzureMonitorExporter.md) — it registers all three signals in one call with Live Metrics support.
+
+## AzureMonitorExporterOptions
+
+Inherits `Azure.Core.ClientOptions`.
+
+| Property | Type | Default | Description |
+|---|---|---|---|
+| `ConnectionString` | `string` | `null` | Application Insights connection string. Falls back to `APPLICATIONINSIGHTS_CONNECTION_STRING` env var. |
+| `Credential` | `TokenCredential` | `null` | Azure AD token credential for Entra-based auth. |
+| `SamplingRatio` | `float` | `1.0F` | Fixed-percentage sampling ratio (0.0–1.0). Only used when `TracesPerSecond` is `null`. |
+| `TracesPerSecond` | `double?` | `5.0` | Rate-limited sampling target. Takes precedence over `SamplingRatio`. Set to `null` to use fixed-percentage sampling. |
+| `StorageDirectory` | `string` | `null` | Custom directory for offline/retry storage. Uses OS temp by default. |
+| `DisableOfflineStorage` | `bool` | `false` | Disables persistent storage for failed telemetry. |
+| `EnableLiveMetrics` | `bool` | `true` | **Ignored** by per-signal methods. Only applies with `UseAzureMonitorExporter`. |
+| `EnableTraceBasedLogsSampler` | `bool` | `true` | When `true`, only logs correlated to sampled traces are exported. Logs without trace context are always exported. |
+
+## Sampling
+
+`AddAzureMonitorTraceExporter` automatically configures a trace sampler — you do not need to set one yourself.
+
+**Two modes**, controlled by `TracesPerSecond` and `SamplingRatio`:
+
+| Mode | Activated when | Sampler | Example |
+|---|---|---|---|
+| Rate-limited (default) | `TracesPerSecond` is non-null | `RateLimitedSampler` — caps throughput to N traces/sec | `TracesPerSecond = 5.0` → ~5 traces/sec |
+| Fixed-percentage | `TracesPerSecond` is `null` | `ApplicationInsightsSampler` — samples a fixed ratio | `SamplingRatio = 0.4F` → 40% of traces |
+
+**Environment variable overrides** — `OTEL_TRACES_SAMPLER` / `OTEL_TRACES_SAMPLER_ARG`:
+
+| `OTEL_TRACES_SAMPLER` | `OTEL_TRACES_SAMPLER_ARG` | Effect |
+|---|---|---|
+| `microsoft.rate_limited` | `5` | `TracesPerSecond = 5.0` |
+| `microsoft.fixed_percentage` | `0.4` | `SamplingRatio = 0.4F`, `TracesPerSecond = null` |
+
+**Log sampling** — when `EnableTraceBasedLogsSampler` is `true` (default), logs correlated to a sampled-out trace are also dropped.
+
+## Minimal example
+
+```csharp
+using Azure.Monitor.OpenTelemetry.Exporter;
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+
+// Connection string from APPLICATIONINSIGHTS_CONNECTION_STRING env var
+using var sdk = OpenTelemetrySdk.Create(builder => builder
+    .WithTracing(tracing => tracing
+        .AddSource("MyApp")
+        .AddAzureMonitorTraceExporter()));
+
+// sdk.Dispose() flushes and shuts down on exit.
+```
+
+## Full example
+
+```csharp
+using Azure.Identity;
+using Azure.Monitor.OpenTelemetry.Exporter;
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+using OpenTelemetry.Metrics;
+
+var credential = new DefaultAzureCredential();
+var connStr = Environment.GetEnvironmentVariable("APPLICATIONINSIGHTS_CONNECTION_STRING");
+
+using var sdk = OpenTelemetrySdk.Create(builder => builder
+    .ConfigureResource(r => r.AddService("my-console-app"))
+    .WithTracing(tracing => tracing
+        .AddSource("MyApp")
+        .AddHttpClientInstrumentation()
+        .AddAzureMonitorTraceExporter(
+            configure: o =>
+            {
+                o.ConnectionString = connStr;
+                o.TracesPerSecond = null;
+                o.SamplingRatio = 0.5F;
+            },
+            credential: credential))
+    .WithMetrics(metrics => metrics
+        .AddMeter("MyApp")
+        .AddAzureMonitorMetricExporter(
+            configure: o => o.ConnectionString = connStr,
+            credential: credential)));
+// Logging intentionally omitted — only traces and metrics exported
+
+// sdk.Dispose() flushes all signals on exit.
+```
+
+## See also
+
+- UseAzureMonitorExporter (all signals)(see in UseAzureMonitorExporter.md)
+- WithTracing(see in WithTracing.md) · WithMetrics(see in WithMetrics.md) · WithLogging(see in WithLogging.md)