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

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

@@ -0,0 +1,53 @@
+---
+title: SqlClientInstrumentation
+category: api-reference
+applies-to: 1.x
+---
+
+# SQL Client Instrumentation
+
+## Package
+
+```
+OpenTelemetry.Instrumentation.SqlClient
+```
+
+## Setup
+
+```csharp
+using OpenTelemetry.Trace;
+
+builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
+    tracing.AddSqlClientInstrumentation(options =>
+    {
+        options.SetDbStatementForText = true;   // Include SQL text
+        options.RecordException = true;          // Record exception details on spans
+    }));
+```
+
+## Options
+
+| Option | Default | Description |
+|---|---|---|
+| `SetDbStatementForText` | `false` | Include SQL command text in `db.statement`. May contain PII. |
+| `SetDbStatementForStoredProcedure` | `true` | Include stored procedure name in `db.statement`. |
+| `RecordException` | `false` | Record exception details as span events when SQL commands fail. |
+| `EnableConnectionLevelAttributes` | `false` | Add `server.address` and `server.port` from the connection string. |
+| `Enrich` | `null` | `Action<Activity, string, object>` to enrich with custom tags. Event names: `OnCustom`. |
+| `Filter` | `null` | `Func<object, bool>` — return `false` to suppress a span. |
+
+## Semantic conventions
+
+| Attribute | Example |
+|---|---|
+| `db.system` | `microsoft.sql_server` |
+| `db.name` | `MyDatabase` |
+| `db.statement` | `SELECT * FROM Users WHERE Id = @Id` |
+| `server.address` | `myserver.database.windows.net` |
+
+## Notes
+
+- Works with both `System.Data.SqlClient` and `Microsoft.Data.SqlClient`.
+- If using EF Core with SQL Server, you may not need this package separately — EF Core instrumentation captures the same spans. Use this when you have raw `SqlCommand` / `SqlConnection` calls alongside or instead of EF Core.
+- `SetDbStatementForText = true` captures raw SQL which may contain sensitive data. Use with caution in production.
+- **Non-DI usage:** Use `config.ConfigureOpenTelemetryBuilder(otel => otel.WithTracing(t => t.AddSqlClientInstrumentation()))` on `TelemetryConfiguration`. See TelemetryClient.md.

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

@@ -0,0 +1,122 @@
+---
+title: TelemetryClient
+category: api-reference
+applies-to: 3.x
+---
+
+# TelemetryClient — Breaking Changes in 3.x
+
+`TelemetryClient` still works in 3.x but several constructors, properties, and method overloads were **removed or changed**. Code that uses removed overloads will not compile after upgrading.
+
+## Removed APIs
+
+| API | Status | Migration |
+| --- | --- | --- |
+| `new TelemetryClient()` (parameterless) | **Removed** | Use `TelemetryClient(TelemetryConfiguration)` via DI (constructor injection). |
+| `client.InstrumentationKey` | **Removed** | Use `TelemetryConfiguration.ConnectionString`. |
+| `TrackPageView(string)` | **Removed** | Use `TrackEvent(name, properties)` or `TrackRequest`. |
+| `TrackPageView(PageViewTelemetry)` | **Removed** | Use `TrackEvent(name, properties)` or `TrackRequest`. |
+
+## Changed method signatures
+
+The `IDictionary<string, double> metrics` parameter was **removed** from several Track methods. Code passing a metrics dictionary will not compile.
+
+| Method | 2.x signature | 3.x signature | Fix |
+| --- | --- | --- | --- |
+| `TrackEvent` | `(string, IDictionary<string,string>, IDictionary<string,double>)` | `(string, IDictionary<string,string>)` | Remove metrics dict. Track metrics separately via `TrackMetric()`. |
+| `TrackException` | `(Exception, IDictionary<string,string>, IDictionary<string,double>)` | `(Exception, IDictionary<string,string>)` | Remove metrics dict. Track metrics separately via `TrackMetric()`. |
+| `TrackAvailability` | 8-param with trailing `IDictionary<string,double>` | 7-param — metrics removed | Remove metrics dict. Track metrics separately via `TrackMetric()`. |
+
+### Example fix — TrackEvent
+
+**2.x (breaks in 3.x):**
+```csharp
+_telemetryClient.TrackEvent("OrderCreated",
+    new Dictionary<string, string> { ["OrderId"] = orderId },
+    new Dictionary<string, double> { ["ProcessingTimeMs"] = elapsed });
+```
+
+**3.x:**
+```csharp
+_telemetryClient.TrackEvent("OrderCreated",
+    new Dictionary<string, string> { ["OrderId"] = orderId });
+_telemetryClient.TrackMetric("OrderProcessingTimeMs", elapsed);
+```
+
+## Other changed APIs
+
+| API | Change | Migration |
+| --- | --- | --- |
+| `TrackDependency` (obsolete 5-param overload) | **Removed** | Use the full overload with `dependencyTypeName`, `target`, `data`, `startTime`, `duration`, `success`. |
+| `GetMetric` (all overloads) | `MetricConfiguration` and `MetricAggregationScope` parameters **removed** | Call the simplified overload: `GetMetric(metricId)` or `GetMetric(metricId, dim1, ...)`. |
+| `Track(ITelemetry)` | Internal routing changed — now delegates to specific Track methods | Review any direct `Track(ITelemetry)` calls; prefer specific Track methods. |
+| `StartOperation<T>` / `StopOperation<T>` | Now uses OpenTelemetry Activities internally | No code change needed — API is the same. |
+
+## Unchanged Track methods — no action needed
+
+These methods and their signatures are **identical** in 3.x:
+
+- `TrackEvent(string eventName)` — single-param overload
+- `TrackEvent(string eventName, IDictionary<string, string> properties)` — 2-param overload (no metrics)
+- `TrackException(Exception exception)` — single-param overload
+- `TrackException(Exception exception, IDictionary<string, string> properties)` — 2-param overload (no metrics)
+- `TrackTrace(string message)` and `TrackTrace(string, SeverityLevel)` and `TrackTrace(string, SeverityLevel, IDictionary<string,string>)`
+- `TrackMetric(string name, double value)` and other `TrackMetric` overloads
+- `TrackRequest(...)` — all overloads
+- `TrackDependency(...)` — full overload (not the obsolete 5-param)
+- `TrackAvailability(...)` — 7-param overload (without metrics dict)
+- `Flush()` and `FlushAsync(CancellationToken)`
+
+## TelemetryContext changes
+
+Several sub-context classes are now **internal** in 3.x:
+
+| Sub-context | Status | Previously accessible properties |
+| --- | --- | --- |
+| `Context.Cloud` | **Internal** | `RoleName`, `RoleInstance` — use `ConfigureResource(r => r.AddService("name"))` instead |
+| `Context.Component` | **Internal** | `Version` — use `ApplicationVersion` in service options |
+| `Context.Device` | **Internal** | `Type`, `Id`, `OperatingSystem`, etc. |
+| `Context.Session` | **Internal** | `Id`, `IsFirst` |
+
+These remain **public**: `Context.User` (`Id`, `AuthenticatedUserId`, `UserAgent`), `Context.Operation` (`Name`), `Context.Location` (`Ip`), `Context.GlobalProperties`.
+
+Properties made internal on remaining public sub-contexts:
+- `User.AccountId` — internal; set via properties dict on Track calls or custom processor
+- `Operation.Id`, `Operation.ParentId` — internal; managed by OpenTelemetry correlation
+- `Operation.CorrelationVector` — removed; no longer needed
+
+## Extensibility — ConfigureOpenTelemetryBuilder
+
+To register custom OpenTelemetry processors or instrumentations alongside TelemetryClient in 3.x:
+
+```csharp
+var config = TelemetryConfiguration.CreateDefault();
+config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+config.ConfigureOpenTelemetryBuilder(otel =>
+{
+    otel.WithTracing(t => t.AddProcessor<MyActivityProcessor>());
+    otel.WithLogging(l => l.AddProcessor<MyLogProcessor>());
+});
+```
+
+When using ASP.NET Core DI, use the service options + `ConfigureOpenTelemetryProvider` pattern instead — see ConfigureOpenTelemetryProvider.md.
+
+## Quick decision guide
+
+| Code pattern found | Action required? |
+| --- | --- |
+| `TrackEvent(name, props, metrics)` — 3 args | **Yes** — remove metrics dict, use `TrackMetric()` separately |
+| `TrackException(ex, props, metrics)` — 3 args | **Yes** — remove metrics dict, use `TrackMetric()` separately |
+| `TrackAvailability(..., metrics)` — 8 args | **Yes** — remove metrics dict, use `TrackMetric()` separately |
+| `TrackPageView(...)` | **Yes** — replace with `TrackEvent()` or `TrackRequest()` |
+| `GetMetric(..., MetricConfiguration, ...)` | **Yes** — remove config/scope params |
+| `new TelemetryClient()` (no args) | **Yes** — use DI or `TelemetryClient(TelemetryConfiguration)` |
+| `client.InstrumentationKey = ...` | **Yes** — use `TelemetryConfiguration.ConnectionString` |
+| `Context.Cloud.RoleName = ...` | **Yes** — use `ConfigureResource` |
+| `TrackEvent(name)` or `TrackEvent(name, props)` | No |
+| `TrackTrace(...)` | No |
+| `TrackMetric(...)` | No |
+| `TrackRequest(...)` | No |
+| `TrackDependency(...)` (full overload) | No |
+| `TrackException(ex)` or `TrackException(ex, props)` | No |
+| `Flush()` | No |

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

@@ -0,0 +1,173 @@
+---
+title: TelemetryConfigurationBuilder
+category: api-reference
+applies-to: 3.x
+---
+
+# TelemetryConfiguration.ConfigureOpenTelemetryBuilder
+
+The non-DI extensibility API for Application Insights 3.x. Use this when you don't have an `IServiceCollection` — classic ASP.NET (`Global.asax`), console apps, or test scenarios.
+
+For DI-based apps (ASP.NET Core, Worker Service), use ConfigureOpenTelemetryTracerProvider(see in ConfigureOpenTelemetryProvider.md) instead.
+
+## API
+
+```csharp
+TelemetryConfiguration.ConfigureOpenTelemetryBuilder(
+    Action<IOpenTelemetryBuilder> configure)
+```
+
+## Setup pattern
+
+```csharp
+using Microsoft.ApplicationInsights.Extensibility;
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+using OpenTelemetry.Logs;
+using OpenTelemetry.Resources;
+
+var config = TelemetryConfiguration.CreateDefault();
+config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+
+config.ConfigureOpenTelemetryBuilder(otel =>
+{
+    // Add custom trace processors
+    otel.WithTracing(tracing =>
+    {
+        tracing.AddProcessor<MyEnrichmentProcessor>();
+        tracing.AddProcessor<MyFilterProcessor>();
+    });
+
+    // Add custom log processors
+    otel.WithLogging(logging =>
+    {
+        logging.AddProcessor<MyLogProcessor>();
+    });
+
+    // Set resource attributes (Cloud.RoleName, etc.)
+    otel.ConfigureResource(r => r.AddService(
+        serviceName: "MyWebApp",
+        serviceInstanceId: Environment.MachineName,
+        serviceVersion: "1.0.0"));
+});
+```
+
+## Add instrumentations
+
+```csharp
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+
+config.ConfigureOpenTelemetryBuilder(otel =>
+{
+    otel.WithTracing(tracing =>
+    {
+        tracing.AddRedisInstrumentation();
+        tracing.AddSqlClientInstrumentation(options =>
+        {
+            options.SetDbStatementForText = true;
+        });
+    });
+});
+```
+
+## Add exporters (dual export)
+
+```csharp
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Logs;
+
+config.ConfigureOpenTelemetryBuilder(otel =>
+{
+    // Console exporter for debugging
+    otel.WithTracing(tracing => tracing.AddConsoleExporter());
+    otel.WithLogging(logging => logging.AddConsoleExporter());
+
+    // OTLP exporter for secondary destination
+    otel.WithTracing(tracing => tracing.AddOtlpExporter());
+    otel.WithMetrics(metrics => metrics.AddOtlpExporter());
+});
+```
+
+## TelemetryClient usage
+
+In classic ASP.NET, create a **single static** `TelemetryClient` instance. `TelemetryConfiguration.CreateDefault()` returns a singleton shared with `ApplicationInsightsHttpModule` — do not create per-request instances.
+
+```csharp
+using Microsoft.ApplicationInsights;
+using Microsoft.ApplicationInsights.Extensibility;
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+using OpenTelemetry.Logs;
+using OpenTelemetry.Resources;
+
+public class MvcApplication : HttpApplication
+{
+    public static TelemetryClient TelemetryClient { get; private set; }
+
+    protected void Application_Start()
+    {
+        var config = TelemetryConfiguration.CreateDefault();
+        config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+        config.ConfigureOpenTelemetryBuilder(otel =>
+        {
+            otel.WithTracing(tracing => tracing.AddProcessor<MyProcessor>());
+            otel.ConfigureResource(r => r.AddService("MyWebApp"));
+        });
+
+        TelemetryClient = new TelemetryClient(config);
+
+        AreaRegistration.RegisterAllAreas();
+        RouteConfig.RegisterRoutes(RouteTable.Routes);
+    }
+
+    protected void Application_End()
+    {
+        TelemetryClient?.Flush();
+        System.Threading.Tasks.Task.Delay(1000).Wait();
+    }
+}
+```
+
+Then in controllers:
+
+```csharp
+public class HomeController : Controller
+{
+    public ActionResult Index()
+    {
+        MvcApplication.TelemetryClient.TrackEvent("HomeVisited");
+        return View();
+    }
+}
+```
+
+## Relationship to ConfigureOpenTelemetryTracerProvider
+
+| Scenario | API to use |
+|---|---|
+| ASP.NET Core / Worker Service (DI) | `services.ConfigureOpenTelemetryTracerProvider(...)` |
+| Classic ASP.NET (Global.asax) | `config.ConfigureOpenTelemetryBuilder(...)` |
+| Console apps without DI | `config.ConfigureOpenTelemetryBuilder(...)` |
+| Tests | `config.ConfigureOpenTelemetryBuilder(...)` |
+
+Both APIs provide access to the same OTel builders (`TracerProviderBuilder`, `MeterProviderBuilder`, `LoggerProviderBuilder`). The difference is the entry point — `IServiceCollection` extension vs `TelemetryConfiguration` method.
+
+## Key differences from 2.x
+
+| 2.x Pattern | 3.x via `ConfigureOpenTelemetryBuilder` |
+|---|---|
+| `config.TelemetryInitializers.Add(new MyInit())` | `otel.WithTracing(t => t.AddProcessor<MyProcessor>())` in `OnStart` |
+| `config.TelemetryProcessorChainBuilder.Use(...)` | `otel.WithTracing(t => t.AddProcessor<MyProcessor>())` in `OnEnd` |
+| `config.TelemetryChannel = new InMemoryChannel()` | Not needed — export managed by OTel |
+| `config.TelemetrySinks.Add(...)` | `otel.WithTracing(t => t.AddOtlpExporter())` |
+
+## Notes
+
+- **`using OpenTelemetry;` is required** — the `WithTracing()`, `WithLogging()`, `WithMetrics()`, and `ConfigureResource()` extension methods on `IOpenTelemetryBuilder` are defined in the root `OpenTelemetry` namespace. Without this using directive, these methods will not resolve. This is separate from `using OpenTelemetry.Trace;` / `using OpenTelemetry.Logs;` which are also needed.
+- `CreateDefault()` returns a **static singleton** in 3.x (not a new instance). Call `ConfigureOpenTelemetryBuilder` only once, in `Application_Start`.
+- Connection string is **required** — 3.x throws if not set. For tests, use a dummy: `InstrumentationKey=00000000-0000-0000-0000-000000000000`.
+- Call `TelemetryClient.Flush()` in `Application_End` followed by a short delay to avoid data loss on shutdown.
+- `GlobalProperties` on `TelemetryClient.Context` works for custom properties. Other `Context` properties (User.Id, Operation.Name) have known propagation limitations in 3.x.

package/dist/Instrumentation/Resources/concepts/dotnet/appinsights-aspnetcore.md

@@ -0,0 +1,113 @@
+---
+title: Application Insights for ASP.NET Core
+category: concept
+applies-to: 3.x
+---
+
+# Application Insights for ASP.NET Core
+
+**Category:** Concept
+**Applies to:** 3.x
+
+## Overview
+
+The `Microsoft.ApplicationInsights.AspNetCore` package provides built-in telemetry collection for ASP.NET Core applications, sending data to Azure Application Insights.
+
+## What It Provides
+
+One line of code enables full observability:
+
+```csharp
+builder.Services.AddApplicationInsightsTelemetry();
+```
+
+### Automatic Collection
+- **Requests** — All incoming HTTP requests with timing, status codes, and URLs
+- **Dependencies** — Outgoing HTTP calls, SQL queries, and Azure SDK calls
+- **Exceptions** — Unhandled exceptions with full stack traces
+- **Performance Counters** — CPU, memory, GC, and thread pool metrics
+- **Logs** — ILogger output (Information level and above by default)
+
+### Built-in Features
+- **Live Metrics** — Real-time monitoring via QuickPulse
+- **Adaptive Sampling** — Automatic volume control (configurable via `TracesPerSecond`)
+- **JavaScript Snippet** — Browser-side telemetry injection for Razor pages
+- **AAD Authentication** — Token-based auth via `TokenCredential`
+
+## Quick Start
+
+### 1. Install Package
+
+```bash
+dotnet add package Microsoft.ApplicationInsights.AspNetCore
+```
+
+### 2. Add to Program.cs
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddApplicationInsightsTelemetry();
+var app = builder.Build();
+```
+
+### 3. Configure Connection String
+
+**Environment variable (recommended):**
+```bash
+APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=xxx;IngestionEndpoint=https://...
+```
+
+**Or in appsettings.json:**
+```json
+{
+  "ApplicationInsights": {
+    "ConnectionString": "InstrumentationKey=xxx;IngestionEndpoint=https://..."
+  }
+}
+```
+
+## Configuration Options
+
+Use `ApplicationInsightsServiceOptions` to customize behavior:
+
+```csharp
+builder.Services.AddApplicationInsightsTelemetry(options =>
+{
+    options.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+    options.EnableQuickPulseMetricStream = true;
+    options.SamplingRatio = 0.5f;   // Collect 50% of telemetry
+});
+```
+
+| Property | Default | Description |
+|----------|---------|-------------|
+| `ConnectionString` | `null` | Application Insights connection string |
+| `Credential` | `null` | AAD `TokenCredential` for token-based auth |
+| `EnableQuickPulseMetricStream` | `true` | Enables Live Metrics |
+| `EnableDependencyTrackingTelemetryModule` | `true` | Tracks HTTP/SQL dependencies |
+| `EnableRequestTrackingTelemetryModule` | `true` | Tracks incoming requests |
+| `TracesPerSecond` | `5` | Rate-limited sampling target |
+| `SamplingRatio` | `null` | Fixed-rate sampling (0.0–1.0); overrides `TracesPerSecond` |
+
+## Connection String Resolution Order
+
+1. `ApplicationInsightsServiceOptions.ConnectionString` (code)
+2. Environment variable `APPLICATIONINSIGHTS_CONNECTION_STRING`
+3. Config key `ApplicationInsights:ConnectionString`
+
+## Extending with OpenTelemetry
+
+Application Insights 3.x is built on OpenTelemetry. You can add additional sources:
+
+```csharp
+builder.Services.AddApplicationInsightsTelemetry();
+builder.Services.AddOpenTelemetry()
+    .WithTracing(t => t.AddSource("MyApp.CustomSource"))
+    .WithMetrics(m => m.AddMeter("MyApp.CustomMeter"));
+```
+
+## See Also
+
+- AddApplicationInsightsTelemetry API (see in AddApplicationInsightsTelemetry.md)
+- ASP.NET Core Setup Example (see in aspnetcore-setup.md)
+- App Insights 2.x to 3.x Migration (see in appinsights-2x-to-3x-code-migration.md)

package/dist/Instrumentation/Resources/concepts/dotnet/aspnet-classic-appinsights.md

@@ -0,0 +1,95 @@
+---
+title: Application Insights for Classic ASP.NET
+category: concepts
+applies-to: dotnet-framework
+---
+
+# Application Insights for Classic ASP.NET
+
+## Overview
+
+Classic ASP.NET applications (.NET Framework 4.6.2+) use `Microsoft.ApplicationInsights.Web` for automatic request, dependency, and exception tracking. In 3.x, the package is built on OpenTelemetry internally.
+
+## How it works
+
+1. **NuGet package install** creates `ApplicationInsights.config` and registers HTTP modules in `Web.config`
+2. **`ApplicationInsightsHttpModule`** runs on every request — reads config, initializes `TelemetryConfiguration`, sets up the OpenTelemetry pipeline
+3. **`TelemetryHttpModule`** (from `OpenTelemetry.Instrumentation.AspNet`) captures request spans via `System.Diagnostics.Activity`
+4. **No code changes needed** — request tracking, dependency tracking, and exception tracking are automatic
+
+## Key configuration files
+
+| File | Purpose |
+|---|---|
+| `ApplicationInsights.config` | Connection string, sampling, feature flags |
+| `Web.config` | HTTP module registration (auto-configured by NuGet) |
+
+## ApplicationInsights.config (3.x format)
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<ApplicationInsights xmlns="http://schemas.microsoft.com/ApplicationInsights/2013/Settings">
+  <ConnectionString>InstrumentationKey=...;IngestionEndpoint=https://...</ConnectionString>
+  <TracesPerSecond>5.0</TracesPerSecond>
+  <EnableTraceBasedLogsSampler>true</EnableTraceBasedLogsSampler>
+  <EnableQuickPulseMetricStream>true</EnableQuickPulseMetricStream>
+  <EnablePerformanceCounterCollectionModule>true</EnablePerformanceCounterCollectionModule>
+  <EnableDependencyTrackingTelemetryModule>true</EnableDependencyTrackingTelemetryModule>
+  <EnableRequestTrackingTelemetryModule>true</EnableRequestTrackingTelemetryModule>
+  <AddAutoCollectedMetricExtractor>true</AddAutoCollectedMetricExtractor>
+</ApplicationInsights>
+```
+
+## Web.config HTTP modules (auto-configured)
+
+```xml
+<system.webServer>
+  <modules>
+    <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" />
+  </modules>
+</system.webServer>
+```
+
+## Extensibility — Custom processors
+
+Use `TelemetryConfiguration.ConfigureOpenTelemetryBuilder` in `Global.asax.cs`:
+
+```csharp
+using Microsoft.ApplicationInsights.Extensibility;
+using OpenTelemetry.Trace;
+using OpenTelemetry.Resources;
+
+protected void Application_Start()
+{
+    var config = TelemetryConfiguration.CreateDefault();
+    config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+    config.ConfigureOpenTelemetryBuilder(otel =>
+    {
+        otel.WithTracing(tracing => tracing.AddProcessor<MyCustomProcessor>());
+        otel.ConfigureResource(r => r.AddService("MyServiceName"));
+    });
+
+    AreaRegistration.RegisterAllAreas();
+    RouteConfig.RegisterRoutes(RouteTable.Routes);
+}
+```
+
+## Requirements
+
+- .NET Framework **4.6.2** or later (3.x raised minimum from 4.5.2)
+- IIS or IIS Express
+- `Microsoft.ApplicationInsights.Web` 3.x NuGet package
+
+## What's automatic (no code needed)
+
+- HTTP request tracking (all incoming requests)
+- SQL dependency tracking
+- HTTP dependency tracking (outgoing `HttpClient` / `WebRequest` calls)
+- Exception tracking
+- Performance counter collection
+- Live Metrics (Quick Pulse)

package/dist/Instrumentation/Resources/concepts/dotnet/azure-monitor-distro.md

@@ -99,4 +99,4 @@ builder.Services.AddOpenTelemetry().UseAzureMonitor(options =>
 
 - OpenTelemetry Pipeline(see in opentelemetry-pipeline.md)
 - UseAzureMonitor API(see in api-reference/dotnet/UseAzureMonitor.md)
-- Basic Setup Example(see in examples/dotnet/aspnetcore-setup.md)
+- Basic Setup Example(see in examples/dotnet/aspnetcore-distro-setup.md)

package/dist/Instrumentation/Resources/concepts/dotnet/opentelemetry-pipeline.md

@@ -53,5 +53,5 @@ See the AddOpenTelemetry API reference(see in AddOpenTelemetry.md) for full setu
 
 ## See Also
 
-- Azure Monitor Distro(see in azure-monitor-distro.md)
+- Application Insights for ASP.NET Core(see in appinsights-aspnetcore.md)
 - AddOpenTelemetry API(see in AddOpenTelemetry.md)

package/dist/Instrumentation/Resources/concepts/nodejs/azure-monitor-overview.md

@@ -0,0 +1,106 @@
+# Azure Monitor for Node.js
+
+Azure Monitor OpenTelemetry for Node.js provides automatic instrumentation and telemetry collection for Node.js applications.
+
+## Key Features
+
+- **Automatic Instrumentation**: Captures HTTP requests, database calls, and external dependencies
+- **Custom Telemetry**: Track custom events, metrics, and traces
+- **Performance Monitoring**: Monitor response times, throughput, and failures
+- **Dependency Tracking**: Understand outgoing calls to databases, APIs, and services
+- **Distributed Tracing**: Follow requests across microservices
+
+## Supported Frameworks
+
+- Express.js
+- Next.js (via instrumentation hook — requires webpack externals configuration)
+- Fastify
+- NestJS
+- Koa
+- Hapi
+- And many more through OpenTelemetry auto-instrumentation
+
+> **Note**: Next.js requires special setup due to its webpack bundling. See the Next.js Setup Guide(see in basic-setup-nextjs.md) for details on externalizing server-only packages.
+
+## Installation
+
+```bash
+npm install @azure/monitor-opentelemetry
+```
+
+## Basic Setup
+
+```javascript
+const { useAzureMonitor } = require('@azure/monitor-opentelemetry');
+
+// Enable Azure Monitor at startup
+useAzureMonitor({
+  azureMonitorExporterOptions: {
+    connectionString: process.env.APPLICATIONINSIGHTS_CONNECTION_STRING
+  }
+});
+
+// Your application code follows...
+const express = require('express');
+const app = express();
+```
+
+## Configuration Options
+
+The `useAzureMonitor()` function accepts configuration for:
+- Connection string
+- Sampling rate
+- Custom resource attributes
+- Instrumentation configuration
+- Logging options
+
+## What Gets Instrumented
+
+### Automatically Captured
+- HTTP/HTTPS requests and responses
+- Database queries (MongoDB, MySQL, PostgreSQL, etc.)
+- Redis operations
+- External HTTP calls
+- Exceptions and errors
+
+### Custom Telemetry
+```javascript
+const { trace } = require('@opentelemetry/api');
+
+// Get current span
+const span = trace.getActiveSpan();
+span?.setAttribute('custom.attribute', 'value');
+
+// Log custom events
+console.log('Custom event logged'); // Captured as trace
+```
+
+## Best Practices
+
+1. **Initialize Early**: Call `useAzureMonitor()` before loading other modules
+2. **Use Environment Variables**: Store connection string in `.env` file
+3. **Enable Sampling**: For high-traffic apps, configure sampling to manage costs
+4. **Add Context**: Use custom attributes to enrich telemetry
+5. **Monitor Performance**: Set up alerts in Azure Monitor for key metrics
+
+## Connection String
+
+Get your connection string from Azure Portal:
+1. Navigate to your Application Insights resource
+2. Go to "Overview" section
+3. Copy the "Connection String" value
+
+Set it as an environment variable:
+```bash
+export APPLICATIONINSIGHTS_CONNECTION_STRING="InstrumentationKey=..."
+```
+
+Or in `.env` file:
+```
+APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=...
+```
+
+## Links
+
+- [Azure Monitor OpenTelemetry for Node.js Documentation](https://learn.microsoft.com/azure/azure-monitor/app/opentelemetry-enable?tabs=nodejs)
+- [OpenTelemetry for Node.js](https://opentelemetry.io/docs/instrumentation/js/)