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

package/dist/Instrumentation/Resources/examples/dotnet/aspnetcore-distro-setup.md

@@ -0,0 +1,156 @@
+---
+title: Basic ASP.NET Core Setup
+category: example
+applies-to: 3.x
+source: ApplicationInsightsDemo/Program.cs
+---
+
+# Basic ASP.NET Core Setup
+
+**Category:** Example  
+**Applies to:** 3.x
+
+## Overview
+
+Complete working example of adding Azure Monitor to a new ASP.NET Core application.
+
+## Step 1: Add Package
+
+```bash
+dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore
+```
+
+Or in `.csproj`:
+
+```xml
+<PackageReference Include="Azure.Monitor.OpenTelemetry.AspNetCore" Version="1.3.0" />
+```
+
+## Step 2: Configure in Program.cs
+
+### Minimal Setup
+
+```csharp
+using Azure.Monitor.OpenTelemetry.AspNetCore;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add Azure Monitor - one line!
+builder.Services.AddOpenTelemetry().UseAzureMonitor();
+
+builder.Services.AddControllers();
+
+var app = builder.Build();
+
+app.MapControllers();
+app.Run();
+```
+
+### With Configuration Options
+
+```csharp
+using Azure.Monitor.OpenTelemetry.AspNetCore;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenTelemetry().UseAzureMonitor(options =>
+{
+    // Connection string from configuration
+    options.ConnectionString = builder.Configuration["AzureMonitor:ConnectionString"];
+    
+    // Sample 50% of requests in production
+    if (!builder.Environment.IsDevelopment())
+    {
+        options.SamplingRatio = 0.5f;
+    }
+});
+
+builder.Services.AddControllers();
+
+var app = builder.Build();
+
+app.MapControllers();
+app.Run();
+```
+
+## Step 3: Configure Connection String
+
+### Option A: Environment Variable (Recommended for Production)
+
+```bash
+export APPLICATIONINSIGHTS_CONNECTION_STRING="InstrumentationKey=xxx;IngestionEndpoint=https://..."
+```
+
+### Option B: appsettings.json
+
+```json
+{
+  "AzureMonitor": {
+    "ConnectionString": "InstrumentationKey=xxx;IngestionEndpoint=https://..."
+  }
+}
+```
+
+### Option C: User Secrets (Development)
+
+```bash
+dotnet user-secrets set "AzureMonitor:ConnectionString" "InstrumentationKey=xxx;..."
+```
+
+## Complete Program.cs
+
+```csharp
+using Azure.Monitor.OpenTelemetry.AspNetCore;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services
+builder.Services.AddControllers();
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+
+// Add Azure Monitor OpenTelemetry
+builder.Services.AddOpenTelemetry().UseAzureMonitor();
+
+var app = builder.Build();
+
+// Configure pipeline
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+app.UseAuthorization();
+app.MapControllers();
+
+app.Run();
+```
+
+## What You Get Automatically
+
+After this setup, Azure Monitor will collect:
+
+| Signal | Data |
+|--------|------|
+| **Requests** | All incoming HTTP requests with timing, status codes |
+| **Dependencies** | Outgoing HTTP calls, SQL queries, Azure SDK calls |
+| **Exceptions** | Unhandled exceptions with stack traces |
+| **Logs** | ILogger output (Information level and above) |
+| **Metrics** | Request rate, response time, CPU, memory |
+
+## Verify It Works
+
+1. Run your application
+2. Make some requests
+3. Check Application Insights in Azure Portal (may take 2-5 minutes)
+4. Look for:
+   - Live Metrics (immediate)
+   - Transaction Search (requests, dependencies)
+   - Failures (exceptions)
+
+## See Also
+
+- Azure Monitor Distro(see in azure-monitor-distro.md)
+- UseAzureMonitor API(see in UseAzureMonitor.md)

package/dist/Instrumentation/Resources/examples/dotnet/aspnetcore-setup.md

@@ -1,29 +1,28 @@
 ---
-title: Basic ASP.NET Core Setup
+title: ASP.NET Core Setup with Application Insights
 category: example
 applies-to: 3.x
-source: ApplicationInsightsDemo/Program.cs
 ---
 
-# Basic ASP.NET Core Setup
+# ASP.NET Core Setup with Application Insights
 
-**Category:** Example  
+**Category:** Example
 **Applies to:** 3.x
 
 ## Overview
 
-Complete working example of adding Azure Monitor to a new ASP.NET Core application.
+Complete working example of adding Application Insights to a new ASP.NET Core application using `Microsoft.ApplicationInsights.AspNetCore`.
 
 ## Step 1: Add Package
 
 ```bash
-dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore
+dotnet add package Microsoft.ApplicationInsights.AspNetCore
 ```
 
 Or in `.csproj`:
 
 ```xml
-<PackageReference Include="Azure.Monitor.OpenTelemetry.AspNetCore" Version="1.3.0" />
+<PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="3.*" />
 ```
 
 ## Step 2: Configure in Program.cs
@@ -31,12 +30,10 @@ Or in `.csproj`:
 ### Minimal Setup
 
 ```csharp
-using Azure.Monitor.OpenTelemetry.AspNetCore;
-
 var builder = WebApplication.CreateBuilder(args);
 
-// Add Azure Monitor - one line!
-builder.Services.AddOpenTelemetry().UseAzureMonitor();
+// Add Application Insights - one line!
+builder.Services.AddApplicationInsightsTelemetry();
 
 builder.Services.AddControllers();
 
@@ -49,20 +46,15 @@ app.Run();
 ### With Configuration Options
 
 ```csharp
-using Azure.Monitor.OpenTelemetry.AspNetCore;
+using Microsoft.ApplicationInsights.AspNetCore.Extensions;
 
 var builder = WebApplication.CreateBuilder(args);
 
-builder.Services.AddOpenTelemetry().UseAzureMonitor(options =>
+builder.Services.AddApplicationInsightsTelemetry(options =>
 {
-    // Connection string from configuration
-    options.ConnectionString = builder.Configuration["AzureMonitor:ConnectionString"];
-    
-    // Sample 50% of requests in production
-    if (!builder.Environment.IsDevelopment())
-    {
-        options.SamplingRatio = 0.5f;
-    }
+    options.ConnectionString = builder.Configuration["ApplicationInsights:ConnectionString"];
+    options.EnableQuickPulseMetricStream = true;
+    options.SamplingRatio = 0.5f;   // Collect 50% of telemetry
 });
 
 builder.Services.AddControllers();
@@ -85,7 +77,7 @@ export APPLICATIONINSIGHTS_CONNECTION_STRING="InstrumentationKey=xxx;IngestionEn
 
 ```json
 {
-  "AzureMonitor": {
+  "ApplicationInsights": {
     "ConnectionString": "InstrumentationKey=xxx;IngestionEndpoint=https://..."
   }
 }
@@ -94,14 +86,12 @@ export APPLICATIONINSIGHTS_CONNECTION_STRING="InstrumentationKey=xxx;IngestionEn
 ### Option C: User Secrets (Development)
 
 ```bash
-dotnet user-secrets set "AzureMonitor:ConnectionString" "InstrumentationKey=xxx;..."
+dotnet user-secrets set "ApplicationInsights:ConnectionString" "InstrumentationKey=xxx;..."
 ```
 
 ## Complete Program.cs
 
 ```csharp
-using Azure.Monitor.OpenTelemetry.AspNetCore;
-
 var builder = WebApplication.CreateBuilder(args);
 
 // Add services
@@ -109,8 +99,8 @@ builder.Services.AddControllers();
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
 
-// Add Azure Monitor OpenTelemetry
-builder.Services.AddOpenTelemetry().UseAzureMonitor();
+// Add Application Insights telemetry
+builder.Services.AddApplicationInsightsTelemetry();
 
 var app = builder.Build();
 
@@ -130,7 +120,7 @@ app.Run();
 
 ## What You Get Automatically
 
-After this setup, Azure Monitor will collect:
+After this setup, Application Insights will collect:
 
 | Signal | Data |
 |--------|------|
@@ -139,6 +129,19 @@ After this setup, Azure Monitor will collect:
 | **Exceptions** | Unhandled exceptions with stack traces |
 | **Logs** | ILogger output (Information level and above) |
 | **Metrics** | Request rate, response time, CPU, memory |
+| **Live Metrics** | Real-time monitoring via QuickPulse |
+| **Performance Counters** | GC, thread pool, process metrics |
+
+## Extending with OpenTelemetry
+
+Application Insights 3.x is built on OpenTelemetry. You can add custom sources and meters:
+
+```csharp
+builder.Services.AddApplicationInsightsTelemetry();
+builder.Services.AddOpenTelemetry()
+    .WithTracing(t => t.AddSource("MyApp.CustomSource"))
+    .WithMetrics(m => m.AddMeter("MyApp.CustomMeter"));
+```
 
 ## Verify It Works
 
@@ -152,5 +155,6 @@ After this setup, Azure Monitor will collect:
 
 ## See Also
 
-- Azure Monitor Distro(see in azure-monitor-distro.md)
-- UseAzureMonitor API(see in UseAzureMonitor.md)
+- Application Insights for ASP.NET Core (see in appinsights-aspnetcore.md)
+- AddApplicationInsightsTelemetry API (see in AddApplicationInsightsTelemetry.md)
+- App Insights 2.x to 3.x Migration (see in appinsights-2x-to-3x-code-migration.md)

package/dist/Instrumentation/Resources/examples/dotnet/workerservice-setup.md

@@ -0,0 +1,154 @@
+---
+title: Basic Worker Service Setup
+category: example
+applies-to: 3.x
+---
+
+# Basic Worker Service Setup
+
+**Category:** Example  
+**Applies to:** 3.x
+
+## Overview
+
+Complete working example of adding Application Insights telemetry to a .NET Worker Service application using `Microsoft.ApplicationInsights.WorkerService`.
+
+Worker Services are long-running background services that don't handle HTTP requests directly. Common examples include:
+- Background job processors
+- Message queue consumers
+- Scheduled task runners
+- Windows Services / Linux daemons
+
+## Step 1: Add Package
+
+```bash
+dotnet add package Microsoft.ApplicationInsights.WorkerService --version 3.0.0-rc1
+```
+
+Or in `.csproj`:
+
+```xml
+<PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="3.0.0-rc1" />
+```
+
+## Step 2: Configure in Program.cs
+
+### Using Host.CreateDefaultBuilder (Traditional Pattern)
+
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+var host = Host.CreateDefaultBuilder(args)
+    .ConfigureServices((context, services) =>
+    {
+        // Add Application Insights telemetry
+        services.AddApplicationInsightsTelemetryWorkerService();
+        
+        // Add your worker service
+        services.AddHostedService<Worker>();
+    })
+    .Build();
+
+await host.RunAsync();
+```
+
+### Using Host.CreateApplicationBuilder (Modern Pattern)
+
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+var builder = Host.CreateApplicationBuilder(args);
+
+// Add Application Insights telemetry
+builder.Services.AddApplicationInsightsTelemetryWorkerService();
+
+// Add your worker service
+builder.Services.AddHostedService<Worker>();
+
+var host = builder.Build();
+await host.RunAsync();
+```
+
+### With Configuration Options
+
+```csharp
+services.AddApplicationInsightsTelemetryWorkerService(options =>
+{
+    // Explicitly set connection string
+    options.ConnectionString = configuration["ApplicationInsights:ConnectionString"];
+
+    // Enable dependency tracking
+    options.EnableDependencyTrackingTelemetryModule = true;
+});
+```
+
+## Step 3: Configure Connection String
+
+### Option A: Environment Variable (Recommended for Production)
+
+```bash
+export APPLICATIONINSIGHTS_CONNECTION_STRING="InstrumentationKey=xxx;IngestionEndpoint=https://..."
+```
+
+### Option B: appsettings.json
+
+```json
+{
+  "ApplicationInsights": {
+    "ConnectionString": "InstrumentationKey=xxx;IngestionEndpoint=https://..."
+  }
+}
+```
+
+## What Gets Instrumented Automatically
+
+The `AddApplicationInsightsTelemetryWorkerService()` method configures:
+
+- **Dependency Tracking**: HTTP client calls, SQL queries, Azure SDK calls
+- **Performance Counters**: CPU, memory, GC metrics
+- **Exception Tracking**: Unhandled exceptions
+- **Custom Telemetry**: Via `TelemetryClient` injection
+
+## Adding Custom Telemetry
+
+Inject `TelemetryClient` into your worker:
+
+```csharp
+public class Worker : BackgroundService
+{
+    private readonly TelemetryClient _telemetryClient;
+    private readonly ILogger<Worker> _logger;
+
+    public Worker(TelemetryClient telemetryClient, ILogger<Worker> logger)
+    {
+        _telemetryClient = telemetryClient;
+        _logger = logger;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            // Track custom events
+            _telemetryClient.TrackEvent("WorkerIteration", new Dictionary<string, string>
+            {
+                ["timestamp"] = DateTime.UtcNow.ToString("O")
+            });
+
+            // Track custom metrics
+            _telemetryClient.TrackMetric("ItemsProcessed", processedCount);
+
+            await Task.Delay(1000, stoppingToken);
+        }
+    }
+}
+```
+
+## Best Practices
+
+1. **Use structured logging**: ILogger integration sends logs to Application Insights automatically
+2. **Track operation context**: Use `TelemetryClient.StartOperation` for long-running operations
+3. **Flush on shutdown**: Call `TelemetryClient.Flush()` before application exits
+4. **Configure sampling**: For high-volume services, configure adaptive sampling to control costs