@azure/mcp-linux-arm64 2.0.0-beta.9 → 2.0.0

package/dist/Instrumentation/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/Instrumentation/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/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/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/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.