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

package/dist/Instrumentation/Resources/migration/dotnet/console-2x-to-3x-code-migration.md

@@ -0,0 +1,106 @@
+---
+title: Console App Application Insights 2.x to 3.x Migration
+category: migration
+applies-to: 3.x
+---
+
+# Console App — AI SDK 2.x → 3.x Migration
+
+## What changed
+
+Console apps use `TelemetryConfiguration` directly (non-DI). In 3.x, the core SDK is rebuilt on OpenTelemetry internally. Several APIs on `TelemetryConfiguration` and `TelemetryClient` are removed or changed.
+
+Key changes:
+- `TelemetryConfiguration.Active` — **Removed**. Use `TelemetryConfiguration.CreateDefault()`. Returns a static singleton in 3.x.
+- `config.InstrumentationKey` — **Removed**. Use `config.ConnectionString` (required — throws if not set).
+- `config.TelemetryInitializers` collection — **Removed**. Use `config.ConfigureOpenTelemetryBuilder(b => b.WithTracing(t => t.AddProcessor<T>()))`.
+- `config.TelemetryProcessors` / `TelemetryProcessorChainBuilder` — **Removed**. Use OpenTelemetry processors.
+- `config.TelemetryChannel` / `TelemetrySinks` — **Removed**. Export pipeline managed by OpenTelemetry internally.
+- `DependencyTrackingTelemetryModule` manual init — **No longer needed**. Dependency tracking is automatic in 3.x.
+- `new TelemetryClient()` (parameterless) — **Removed**. Use `new TelemetryClient(config)`.
+- `SetAzureTokenCredential(object)` — Signature changed to `SetAzureTokenCredential(TokenCredential)` (strongly typed).
+
+## Before / after
+
+**2.x**
+```csharp
+using Microsoft.ApplicationInsights;
+using Microsoft.ApplicationInsights.DependencyCollector;
+using Microsoft.ApplicationInsights.Extensibility;
+
+var config = TelemetryConfiguration.Active; // or CreateDefault()
+config.InstrumentationKey = "your-ikey";
+config.TelemetryInitializers.Add(new MyInitializer());
+
+var dtModule = new DependencyTrackingTelemetryModule();
+dtModule.Initialize(config);
+
+var client = new TelemetryClient(config);
+client.TrackEvent("Started");
+// ...
+client.Flush();
+```
+
+**3.x**
+```csharp
+using Microsoft.ApplicationInsights;
+using Microsoft.ApplicationInsights.Extensibility;
+using OpenTelemetry;
+
+var config = TelemetryConfiguration.CreateDefault();
+config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+
+// Extensibility via OpenTelemetry builder
+config.ConfigureOpenTelemetryBuilder(builder =>
+{
+    builder.WithTracing(tracing => tracing.AddProcessor<MyActivityProcessor>());
+});
+
+var client = new TelemetryClient(config);
+client.TrackEvent("Started");
+// ...
+client.Flush();
+```
+
+## Removed APIs
+
+| API | Status | Replacement |
+|---|---|---|
+| `TelemetryConfiguration.Active` | **Removed** | `TelemetryConfiguration.CreateDefault()` (static singleton) |
+| `TelemetryConfiguration(string ikey)` | **Removed** | `CreateDefault()` + set `ConnectionString` |
+| `config.InstrumentationKey` | **Removed** | `config.ConnectionString` |
+| `config.TelemetryInitializers` | **Removed** | `config.ConfigureOpenTelemetryBuilder(...)` with `AddProcessor<T>()` |
+| `config.TelemetryProcessors` | **Removed** | `config.ConfigureOpenTelemetryBuilder(...)` with `AddProcessor<T>()` |
+| `config.TelemetryChannel` | **Removed** | Managed internally by OpenTelemetry |
+| `config.TelemetrySinks` | **Removed** | Use OpenTelemetry exporters via `ConfigureOpenTelemetryBuilder` |
+| `new TelemetryClient()` | **Removed** | `new TelemetryClient(config)` |
+| `client.InstrumentationKey` | **Removed** | Use `config.ConnectionString` |
+| `DependencyTrackingTelemetryModule` | **Not needed** | Dependency tracking is automatic |
+| `OperationCorrelationTelemetryInitializer` | **Not needed** | Correlation is automatic via OpenTelemetry |
+| `HttpDependenciesParsingTelemetryInitializer` | **Not needed** | Parsing is automatic |
+
+## New APIs
+
+| API | Description |
+|---|---|
+| `config.ConnectionString` | Required. Set before creating `TelemetryClient`. |
+| `config.ConfigureOpenTelemetryBuilder(Action<IOpenTelemetryBuilder>)` | Hook for adding processors, exporters, instrumentation. **Requires `using OpenTelemetry;`** — the `WithTracing()`, `WithLogging()`, `WithMetrics()`, and `ConfigureResource()` extension methods are in the root `OpenTelemetry` namespace. |
+| `config.SetAzureTokenCredential(TokenCredential)` | AAD auth (strongly typed — was `object` in 2.x) |
+| `config.SamplingRatio` | Fixed-rate sampling (0.0–1.0) |
+| `config.TracesPerSecond` | Rate-limited sampling |
+
+## Migration steps
+
+1. Replace `TelemetryConfiguration.Active` with `TelemetryConfiguration.CreateDefault()`
+2. Replace `config.InstrumentationKey = "..."` with `config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=..."`
+3. Remove manual `DependencyTrackingTelemetryModule` initialization — dependency tracking is automatic
+4. Remove `OperationCorrelationTelemetryInitializer` and `HttpDependenciesParsingTelemetryInitializer` — correlation and parsing are automatic
+5. Migrate custom `ITelemetryInitializer` implementations to `BaseProcessor<Activity>` — register via `config.ConfigureOpenTelemetryBuilder(b => b.WithTracing(t => t.AddProcessor<T>()))`
+6. Update `SetAzureTokenCredential((object)cred)` to `SetAzureTokenCredential(cred)` (remove cast — parameter is now `TokenCredential`)
+7. Update the NuGet package: `Microsoft.ApplicationInsights` to `3.*`, remove `Microsoft.ApplicationInsights.DependencyCollector`
+
+## See also
+
+- [TelemetryConfigurationBuilder API reference](learn://api-reference/dotnet/TelemetryConfigurationBuilder.md)
+- [TelemetryClient API reference](learn://api-reference/dotnet/TelemetryClient.md)
+- [AAD Authentication Migration](learn://migration/dotnet/aad-authentication-migration.md)

package/dist/Instrumentation/Resources/migration/dotnet/ilogger-migration.md

@@ -0,0 +1,54 @@
+---
+title: ILogger and Log Filtering Migration (2.x to 3.x)
+category: migration
+applies-to: 3.x
+---
+
+# ILogger and Log Filtering Migration (2.x → 3.x)
+
+## What changed
+
+In 2.x, `AddApplicationInsightsTelemetry()` already captured ILogger output automatically. However, some codebases also called `AddApplicationInsights()` on `ILoggingBuilder` explicitly — for example, to configure `ApplicationInsightsLoggerOptions` or to add category-level log filters targeting `ApplicationInsightsLoggerProvider`.
+
+In 3.x, ILogger capture remains automatic. The difference is that the underlying provider is now `OpenTelemetryLoggerProvider` (from the OpenTelemetry SDK). Any explicit `AddApplicationInsights()` calls and filters targeting `ApplicationInsightsLoggerProvider` must be updated.
+
+| Aspect | 2.x | 3.x |
+|---|---|---|
+| Logger provider | `ApplicationInsightsLoggerProvider` (explicit) | `OpenTelemetryLoggerProvider` (automatic) |
+| Registration | `loggingBuilder.AddApplicationInsights()` | Not needed — automatic |
+| Category filters | `AddFilter<ApplicationInsightsLoggerProvider>(...)` | `AddFilter<OpenTelemetryLoggerProvider>(...)` or plain `AddFilter(...)` |
+| Advanced filtering | `ITelemetryProcessor` | `BaseProcessor<LogRecord>` via `ConfigureOpenTelemetryLoggerProvider` |
+
+## Before / after
+
+**2.x**
+```csharp
+using Microsoft.Extensions.Logging.ApplicationInsights;
+
+builder.Services.AddLogging(loggingBuilder =>
+{
+    loggingBuilder.AddApplicationInsights(options =>
+    {
+        options.TrackExceptionsAsExceptionTelemetry = true;
+        options.IncludeScopes = true;
+    });
+    loggingBuilder.AddFilter<ApplicationInsightsLoggerProvider>("Microsoft.AspNetCore", LogLevel.Warning);
+    loggingBuilder.AddFilter<ApplicationInsightsLoggerProvider>("MyApp", LogLevel.Information);
+});
+```
+
+**3.x**
+```csharp
+using OpenTelemetry.Logs; // Required for OpenTelemetryLoggerProvider
+
+// Logging is automatic — just configure filters targeting the OTel provider
+builder.Logging.AddFilter<OpenTelemetryLoggerProvider>("Microsoft.AspNetCore", LogLevel.Warning);
+builder.Logging.AddFilter<OpenTelemetryLoggerProvider>("MyApp", LogLevel.Information);
+```
+
+## Migration steps
+
+1. **Remove `AddApplicationInsights()`** — delete the call and its options lambda (`TrackExceptionsAsExceptionTelemetry`, `IncludeScopes` no longer exist).
+2. **Replace log filters** — change `AddFilter<ApplicationInsightsLoggerProvider>` to `AddFilter<OpenTelemetryLoggerProvider>`, or use a plain `AddFilter(category, level)`. Add `using OpenTelemetry.Logs;` if targeting the provider specifically.
+3. **Update usings** — remove `using Microsoft.Extensions.Logging.ApplicationInsights;`.
+4. **Remove the package** — `Microsoft.Extensions.Logging.ApplicationInsights` is no longer needed.

package/dist/Instrumentation/Resources/migration/dotnet/workerservice-2x-to-3x-code-migration.md

@@ -0,0 +1,126 @@
+---
+title: WorkerService 2.x to 3.x Code Migration
+category: migration
+applies-to: 3.x
+---
+
+# Worker Service 2.x → 3.x Code Migration
+
+## What changed
+
+3.x uses OpenTelemetry under the hood. The main entry point is the same — `AddApplicationInsightsTelemetryWorkerService()` — but several options and an extension method were removed.
+
+Key changes:
+- `InstrumentationKey` → use `ConnectionString`
+- `EnableAdaptiveSampling` → use `TracesPerSecond` (default `5`) or `SamplingRatio`
+- Logging is automatic — no additional logger provider needed
+- New: `Credential` for AAD authentication, `EnableTraceBasedLogsSampler` for log sampling control
+
+## Before / after
+
+**2.x**
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+
+builder.ConfigureServices(services =>
+{
+    services.AddApplicationInsightsTelemetryWorkerService(options =>
+    {
+        options.InstrumentationKey = "your-ikey";          // Removed in 3.x
+        options.EnableAdaptiveSampling = false;             // Removed in 3.x
+        options.DeveloperMode = true;                       // Removed in 3.x
+    });
+});
+```
+
+**3.x**
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.ApplicationInsights.WorkerService;
+
+builder.ConfigureServices(services =>
+{
+    services.AddApplicationInsightsTelemetryWorkerService(options =>
+    {
+        options.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+        options.SamplingRatio = 1.0f;       // No sampling (collect everything)
+        // DeveloperMode — no replacement needed, remove the line
+    });
+});
+```
+
+Or set `APPLICATIONINSIGHTS_CONNECTION_STRING` as an environment variable and call `AddApplicationInsightsTelemetryWorkerService()` with no arguments.
+
+## Property changes
+
+| Property | Status | Action required |
+|---|---|---|
+| `ConnectionString` | Unchanged | None. |
+| `ApplicationVersion` | Unchanged | None. |
+| `EnableQuickPulseMetricStream` | Unchanged | None. Default `true`. |
+| `EnablePerformanceCounterCollectionModule` | Unchanged | None. Default `true`. |
+| `EnableDependencyTrackingTelemetryModule` | Unchanged | None. Default `true`. |
+| `AddAutoCollectedMetricExtractor` | Unchanged | None. Default `true`. |
+| `InstrumentationKey` | **Removed** | Use `ConnectionString`. |
+| `EnableAdaptiveSampling` | **Removed** | Use `TracesPerSecond` or `SamplingRatio`. |
+| `DeveloperMode` | **Removed** | Delete the line. |
+| `EndpointAddress` | **Removed** | Endpoint is now part of `ConnectionString`. |
+| `EnableHeartbeat` | **Removed** | Delete the line. |
+| `EnableDebugLogger` | **Removed** | Delete the line. |
+| `DependencyCollectionOptions` | **Removed** | Delete the line. |
+| `EnableEventCounterCollectionModule` | **Removed** | Delete the line. |
+| `EnableAppServicesHeartbeatTelemetryModule` | **Removed** | Delete the line; heartbeat is automatic. |
+| `EnableAzureInstanceMetadataTelemetryModule` | **Removed** | Delete the line; resource detection is automatic. |
+| `EnableDiagnosticsTelemetryModule` | **Removed** | Delete the line. |
+| `Credential` | **New** | `TokenCredential`, default `null`. Set for AAD auth. |
+| `TracesPerSecond` | **New** | `double?`, effective default `5`. Rate-limited sampling. |
+| `SamplingRatio` | **New** | `float?`, default `null`. Fixed-rate sampling (0.0–1.0). |
+| `EnableTraceBasedLogsSampler` | **New** | `bool?`, effective default `true`. Logs follow parent trace sampling. |
+
+## Removed extension methods
+
+| Method | Replacement |
+|---|---|
+| `AddApplicationInsightsTelemetryWorkerService(string instrumentationKey)` | Use parameterless overload + `ConnectionString` in options or env var. |
+
+## TelemetryClient changes
+
+| Change | Details |
+|---|---|
+| `TrackEvent` | 3-param overload `(string, IDictionary<string,string>, IDictionary<string,double>)` **removed** — metrics dict dropped. Use 2-param overload and track metrics separately via `TrackMetric()`. |
+| `TrackException` | 3-param overload with `IDictionary<string,double>` **removed**. Use 2-param overload and track metrics separately via `TrackMetric()`. |
+| `TrackAvailability` | 8-param overload with trailing `IDictionary<string,double>` **removed**. Use 7-param overload and track metrics separately via `TrackMetric()`. |
+| `TrackPageView` | **Removed entirely** (both overloads). Use `TrackEvent` or `TrackRequest` instead. |
+| `GetMetric` | `MetricConfiguration` and `MetricAggregationScope` params **removed** from all overloads. Use simplified `GetMetric(metricId, ...)`. |
+| parameterless `TelemetryClient()` | **Removed**. Use `TelemetryClient(TelemetryConfiguration)` via DI. |
+| `client.InstrumentationKey` | **Removed**. Use `TelemetryConfiguration.ConnectionString`. |
+| `TrackTrace`, `TrackMetric`, `TrackRequest`, `TrackDependency` (full overload), `Flush` | **Unchanged** — no action needed. |
+
+## Migration steps
+
+1. Update the package:
+   ```xml
+   <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="3.*" />
+   ```
+
+2. Find and replace in your code:
+   - `InstrumentationKey = "..."` → `ConnectionString = "InstrumentationKey=...;IngestionEndpoint=..."`
+   - `EnableAdaptiveSampling = false` → `SamplingRatio = 1.0f` (or set `TracesPerSecond`)
+   - Delete any lines setting `DeveloperMode`, `EndpointAddress`, `EnableHeartbeat`, `EnableDebugLogger`, `DependencyCollectionOptions`, `EnableEventCounterCollectionModule`, `EnableAppServicesHeartbeatTelemetryModule`, `EnableAzureInstanceMetadataTelemetryModule`, or `EnableDiagnosticsTelemetryModule`
+   - Replace `AddApplicationInsightsTelemetryWorkerService("your-ikey")` with `AddApplicationInsightsTelemetryWorkerService()` and set `ConnectionString` via options or env var
+
+3. Migrate TelemetryClient breaking calls:
+   - Remove `IDictionary<string, double> metrics` parameter from `TrackEvent`/`TrackException`/`TrackAvailability` calls (track metrics separately via `TrackMetric()`). Replace `TrackPageView` with `TrackEvent` or `TrackRequest`. Remove `GetMetric` overloads that take `MetricConfiguration`/`MetricAggregationScope`.
+
+4. Build and verify — the `Enable*` flags (`EnableQuickPulseMetricStream`, `EnableDependencyTrackingTelemetryModule`, etc.) still work with the same defaults. No changes needed for those.
+
+## Behavior notes
+
+- `TracesPerSecond` is the default sampling mode (effective default `5`). No configuration needed for most apps.
+- Connection string resolution order: `ApplicationInsightsServiceOptions.ConnectionString` → `APPLICATIONINSIGHTS_CONNECTION_STRING` env var → `ApplicationInsights:ConnectionString` in config.
+
+## See also
+
+- No-code-change migration(see in workerservice-2x-to-3x-no-code-change.md)
+- AddApplicationInsightsTelemetryWorkerService API reference(see in AddApplicationInsightsTelemetryWorkerService.md)
+- TelemetryClient breaking changes(see in TelemetryClient.md)

package/dist/Instrumentation/Resources/migration/dotnet/workerservice-2x-to-3x-no-code-change.md

@@ -0,0 +1,102 @@
+---
+title: WorkerService 2.x to 3.x — No-Code-Change Migration
+category: migration
+applies-to: 3.x
+---
+
+# Worker Service 2.x → 3.x — No Code Change
+
+## When this applies
+
+Your migration requires **only a package upgrade** (no code changes) if both of these are true:
+
+1. You call `AddApplicationInsightsTelemetryWorkerService()` with no arguments, an `IConfiguration`, or with options that only set **unchanged properties**.
+2. You do not call `AddApplicationInsightsTelemetryWorkerService(string instrumentationKey)`.
+
+### Unchanged properties (safe to keep as-is)
+
+| Property | Default |
+|---|---|
+| `ConnectionString` | `null` |
+| `ApplicationVersion` | Entry assembly version |
+| `EnableQuickPulseMetricStream` | `true` |
+| `EnablePerformanceCounterCollectionModule` | `true` |
+| `EnableDependencyTrackingTelemetryModule` | `true` |
+| `AddAutoCollectedMetricExtractor` | `true` |
+
+If your code only uses these properties (or none at all), no code changes are needed.
+
+## Migration steps
+
+### 1. Update the package
+
+```xml
+<PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="3.*" />
+```
+
+### 2. Build and run
+
+That's it. No code changes required.
+
+## Examples that work without changes
+
+**Parameterless call:**
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+
+var builder = Host.CreateDefaultBuilder(args);
+builder.ConfigureServices(services =>
+{
+    services.AddApplicationInsightsTelemetryWorkerService();
+});
+var host = builder.Build();
+await host.RunAsync();
+```
+
+**IConfiguration overload:**
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+
+var builder = Host.CreateDefaultBuilder(args);
+builder.ConfigureServices(services =>
+{
+    services.AddApplicationInsightsTelemetryWorkerService(builder.Configuration);
+});
+var host = builder.Build();
+await host.RunAsync();
+```
+
+**Options with only unchanged properties:**
+```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.EnableDependencyTrackingTelemetryModule = true;
+    });
+});
+var host = builder.Build();
+await host.RunAsync();
+```
+
+All three examples above work identically in 2.x and 3.x.
+
+## What changes under the hood
+
+Even though your code stays the same, 3.x brings these improvements automatically:
+
+- Telemetry is now collected via OpenTelemetry — better standards alignment and ecosystem compatibility.
+- `TracesPerSecond` (effective default `5`) provides rate-limited sampling out of the box. No configuration needed.
+- Logging is integrated automatically — `ILogger` output is exported to Application Insights without additional setup.
+- Azure resource detection (App Service, VM) happens automatically.
+
+## See also
+
+- WorkerService 2.x to 3.x Code Migration(see in workerservice-2x-to-3x-code-migration.md)
+- AddApplicationInsightsTelemetryWorkerService API reference(see in AddApplicationInsightsTelemetryWorkerService.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure/mcp-linux-arm64",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.0",
   "description": "Azure MCP Server - Model Context Protocol implementation for Azure, for linux on arm64",
   "author": "Microsoft",
   "homepage": "https://github.com/Microsoft/mcp/blob/main/servers/Azure.Mcp.Server#readme",