### Add Manual Setup Package

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/console-setup.md

Install the Microsoft.ApplicationInsights NuGet package for manual telemetry configuration in console applications without the Generic Host.

```bash
dotnet add package Microsoft.ApplicationInsights --version 3.*
```

--------------------------------

### Install Application Insights Skill for GitHub Copilot

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/AGENTS.md

Copies the Application Insights setup skill to the .github/skills directory for GitHub Copilot to discover.

```bash
cp -r skills/applicationinsights-setup .github/skills/applicationinsights-setup
```

--------------------------------

### Install Application Insights Skill for Cursor

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/AGENTS.md

Copies the Application Insights setup skill to the .cursor/skills directory for Cursor to discover.

```bash
cp -r skills/applicationinsights-setup .cursor/skills/applicationinsights-setup
```

--------------------------------

### Install Application Insights Skill for Codex

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/AGENTS.md

Copies the Application Insights setup skill to the .agents/skills directory for Codex to discover.

```bash
cp -r skills/applicationinsights-setup .agents/skills/applicationinsights-setup
```

--------------------------------

### Install Application Insights Skill for Claude Code (Copy)

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/AGENTS.md

Copies the Application Insights setup skill to the .claude/skills directory for Claude Code to discover.

```bash
cp -r skills/applicationinsights-setup .claude/skills/applicationinsights-setup
```

--------------------------------

### SDK Version Examples

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/docs/versions_and_names.md

Provides concrete examples of valid SDK version strings, demonstrating the use of prefixes, SDK names, and semantic versions.

```text
  r_dotnet:2.0.0-12345
    dotnet:2.0.0-beta.1
```

--------------------------------

### Quick Install for Claude Code

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/Readme.md

Use this command to quickly install the Application Insights setup skill for Claude Code. After installation, you can ask your agent to add Application Insights to your app.

```bash
cp -r skills/applicationinsights-setup/ ~/.claude/skills/
```

--------------------------------

### ApplicationInsights.config: 2.x Configuration Example

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/WEB/Readme.md

Example of the ApplicationInsights.config file structure for version 2.x, including TelemetryInitializers and TelemetryModules.

```xml
<ApplicationInsights>
  <InstrumentationKey>...</InstrumentationKey>
  <TelemetryInitializers>
    <Add Type="MyApp.CustomInitializer, MyApp" />
  </TelemetryInitializers>
  <TelemetryModules>
    <Add Type="Microsoft.ApplicationInsights.Web.RequestTrackingTelemetryModule, Microsoft.AI.Web" />
  </TelemetryModules>
</ApplicationInsights>
```

--------------------------------

### Add SQL Client Instrumentation Package

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/sql-client.md

Install the SQL client instrumentation package using the .NET CLI.

```bash
dotnet add package OpenTelemetry.Instrumentation.SqlClient
```

--------------------------------

### Install Application Insights Skill for Claude Code (Add Directory)

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/AGENTS.md

Adds the Application Insights setup skill directory to Claude's configuration without copying.

```bash
claude --add-dir /path/to/ApplicationInsights-dotnet/skills/applicationinsights-setup
```

--------------------------------

### Install Application Insights Web Package (.NET CLI)

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/WEB/Readme.md

Install the Microsoft.ApplicationInsights.Web NuGet package using the .NET CLI.

```bash
dotnet add package Microsoft.ApplicationInsights.Web
```

--------------------------------

### Minimal Application Insights Setup in Program.cs

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/aspnetcore-greenfield.md

Configure Application Insights telemetry with minimal setup in the Program.cs file for a new ASP.NET Core application.

```csharp
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Add Application Insights telemetry
builder.Services.AddApplicationInsightsTelemetry();

builder.Services.AddControllers();

var app = builder.Build();

app.MapControllers();
app.Run();
```

--------------------------------

### Setup SQL Client Instrumentation in Non-DI Usage

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/sql-client.md

For console applications or libraries not using Dependency Injection, configure SQL client instrumentation directly with TelemetryConfiguration. This example sets the connection string, adds SQL client instrumentation, and customizes options.

```csharp
using OpenTelemetry.Instrumentation.SqlClient;

var config = TelemetryConfiguration.CreateDefault();
config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
config.ConfigureOpenTelemetryBuilder(otel =>
{
    otel.WithTracing(t => t.AddSqlClientInstrumentation());

    otel.Services.Configure<SqlClientTraceInstrumentationOptions>(options =>
    {
        options.SetDbStatementForText = true;
        options.RecordException = true;
    });
});
```

--------------------------------

### Add Entity Framework Core Instrumentation Package

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/entity-framework.md

Install the OpenTelemetry.Instrumentation.EntityFrameworkCore NuGet package using the .NET CLI.

```bash
dotnet add package OpenTelemetry.Instrumentation.EntityFrameworkCore
```

--------------------------------

### ApplicationInsights.config: 3.x Configuration Example

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/WEB/Readme.md

Example of the ApplicationInsights.config file structure for version 3.x, showing the use of ConnectionString and noting that TelemetryInitializers and TelemetryModules are no longer supported.

```xml
<ApplicationInsights>
  <ConnectionString>InstrumentationKey=...;IngestionEndpoint=https://...</ConnectionString>
  <!-- TelemetryInitializers and TelemetryModules no longer supported -->
</ApplicationInsights>
```

--------------------------------

### Add HTTP Client Instrumentation Package

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/http-instrumentation.md

Install the OpenTelemetry HTTP client instrumentation package using the .NET CLI.

```bash
dotnet add package OpenTelemetry.Instrumentation.Http
```

--------------------------------

### Create a Basic Activity

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/custom-activities.md

Start a new activity using the ActivitySource. Ensure you use a 'using' statement to automatically dispose of the activity when it goes out of scope.

```csharp
using var activity = MyAppTracing.Source.StartActivity("ProcessOrder");
// ... do work ...
```

--------------------------------

### ILogger Setup in Application Insights 3.x

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/ilogger-migration.md

Demonstrates the simplified logging setup in Application Insights 3.x, where logging is automatic. It also shows how to apply log level filtering using standard ILoggingBuilder.

```csharp
// No logging setup needed — it's automatic.
// ILogger output flows to Application Insights via OpenTelemetry.

// To filter log levels, use standard ILoggingBuilder:
builder.Logging.AddFilter<OpenTelemetryLoggerProvider>("", LogLevel.Warning);
```

--------------------------------

### Basic Redis Instrumentation Setup with DI

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/redis-cache.md

Register IConnectionMultiplexer and add Redis instrumentation to the OpenTelemetry tracer provider in a DI-enabled application.

```csharp
using OpenTelemetry.Instrumentation.StackExchangeRedis;

// Register IConnectionMultiplexer in DI
builder.Services.AddSingleton<IConnectionMultiplexer>(
    ConnectionMultiplexer.Connect("localhost:6379")));

// Add Redis instrumentation
builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
    tracing.AddRedisInstrumentation());
```

--------------------------------

### Add OTLP Exporter Package

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/otlp-exporter.md

Install the OTLP exporter package using the .NET CLI.

```bash
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
```

--------------------------------

### Before: ITelemetryInitializer in v2.x

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/initializer-migration.md

Example of implementing ITelemetryInitializer in v2.x to enrich telemetry with global properties and cloud role name. Registration is done via dependency injection.

```csharp
using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.Extensibility;

public class MyInitializer : ITelemetryInitializer
{
    public void Initialize(ITelemetry telemetry)
    {
        telemetry.Context.GlobalProperties["environment"] = "production";
        telemetry.Context.Cloud.RoleName = "MyService";
    }
}

// Registration:
services.AddSingleton<ITelemetryInitializer, MyInitializer>();
```

--------------------------------

### After: BaseProcessor<Activity> for Trace Enrichment in v3.x

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/initializer-migration.md

Example of migrating to BaseProcessor<Activity> in v3.x for trace enrichment. It demonstrates setting tags for environment and cloud role name using OpenTelemetry resource configuration.

```csharp
using System.Diagnostics;
using OpenTelemetry;

public class MyEnrichmentProcessor : BaseProcessor<Activity>
{
    public override void OnStart(Activity data)
    {
        data.SetTag("deployment.environment", "production");
    }
}

// Registration:
builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
    tracing.AddProcessor<MyEnrichmentProcessor>());
```

--------------------------------

### Configure Application Insights 2.x

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/code-migration.md

Example of configuring Application Insights 2.x using `InstrumentationKey` and `EnableAdaptiveSampling`.

```csharp
builder.Services.AddApplicationInsightsTelemetry(options =>
{
    options.InstrumentationKey = "your-ikey";          // Removed
    options.EnableAdaptiveSampling = false;             // Removed
    options.DeveloperMode = true;                       // Removed
});
```

--------------------------------

### Configure Application Insights 3.x

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/code-migration.md

Example of configuring Application Insights 3.x using `ConnectionString` and `SamplingRatio`.

```csharp
builder.Services.AddApplicationInsightsTelemetry(options =>
{
    options.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
    options.SamplingRatio = 1.0f;       // No sampling (collect everything)
    // DeveloperMode — no replacement, remove the line
});
```

--------------------------------

### Add Application Insights Package

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/aspnetcore-greenfield.md

Install the Application Insights ASP.NET Core package using the .NET CLI.

```bash
dotnet add package Microsoft.ApplicationInsights.AspNetCore
```

--------------------------------

### Create Default Telemetry Configuration

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/BASE/README.md

Create a default TelemetryConfiguration and set the connection string. This is the starting point for SDK configuration.

```csharp
var configuration = TelemetryConfiguration.CreateDefault();
configuration.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
```

--------------------------------

### Start and Stop ETW Trace Session with Logman

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/troubleshooting/ETW/Readme.md

Use Logman to start an ETW trace session named 'ai-channel' using a provider list file and then stop the session.

```bash
logman -start ai-channel -pf providers.txt -ets -bs 1024 -nb 100 256
logman -stop ai-channel -ets
```

--------------------------------

### ILogger Setup in Application Insights 2.x

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/ilogger-migration.md

Shows the manual logger provider registration and configuration methods used in Application Insights 2.x. This setup is no longer required in version 3.x.

```csharp
// Manual logger provider registration (no longer needed)
builder.Logging.AddApplicationInsights();

// Or via configuration
builder.Logging.AddFilter<ApplicationInsightsLoggerProvider>("", LogLevel.Information);
```

--------------------------------

### Add Redis Instrumentation Package

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/redis-cache.md

Install the OpenTelemetry StackExchangeRedis instrumentation package using the .NET CLI.

```bash
dotnet add package OpenTelemetry.Instrumentation.StackExchangeRedis
```

--------------------------------

### Application Insights Setup with Configuration Options

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/aspnetcore-greenfield.md

Configure Application Insights telemetry with custom options, such as connection string and sampling rate, in Program.cs.

```csharp
using Microsoft.Extensions.DependencyInjection;
using Microsoft.ApplicationInsights.AspNetCore.Extensions;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddApplicationInsightsTelemetry(options =>
{
    options.ConnectionString = builder.Configuration["ApplicationInsights:ConnectionString"];

    // Rate-limited sampling (default is 5 traces/sec)
    options.TracesPerSecond = 10.0;
});

builder.Services.AddControllers();

var app = builder.Build();

app.MapControllers();
app.Run();
```

--------------------------------

### BaseProcessor<LogRecord> for Log Enrichment in v3.x

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/initializer-migration.md

Example of implementing BaseProcessor<LogRecord> in v3.x to enrich log records with custom attributes, such as deployment environment.

```csharp
public class LogEnrichmentProcessor : BaseProcessor<LogRecord>
{
    public override void OnEnd(LogRecord data)
    {
        // Example: add a custom attribute to all log records
        var attributes = new List<KeyValuePair<string, object?>>(data.Attributes ?? [])
        {
            new("deployment.environment", "production")
        };
        data.Attributes = attributes;
    }
}
```

--------------------------------

### Create Provider List for Logman

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/troubleshooting/ETW/Readme.md

Create a text file listing the GUIDs of Application Insights ETW providers to be collected by Logman.

```text
{4c4280fb-382a-56be-9a13-fab0d03395f6}
{74af9f20-af6a-5582-9382-f21f674fb271}
{a62adddb-6b4b-519d-7ba1-f983d81623e0}
```

--------------------------------

### Customize SQL Client Instrumentation

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/NETCORE/Readme.md

Enable SQL client instrumentation to record exceptions. Ensure the OpenTelemetry.Instrumentation.SqlClient package is installed.

```csharp
// Install: dotnet add package --prerelease OpenTelemetry.Instrumentation.SqlClient

using OpenTelemetry.Instrumentation.SqlClient;

builder.Services.AddApplicationInsightsTelemetry();

builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => 
{
    builder.AddSqlClientInstrumentation(options =>
    {
        options.RecordException = true;
    });
});
```

--------------------------------

### After: BaseProcessor<Activity> with IHttpContextAccessor in v3.x

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/initializer-migration.md

Example of migrating to BaseProcessor<Activity> in v3.x to access HttpContext via IHttpContextAccessor for enriching telemetry with user ID and tenant ID.

```csharp
public sealed class UserTelemetryEnrichment : BaseProcessor<Activity>
{
    private readonly IHttpContextAccessor _httpContextAccessor;

    public UserTelemetryEnrichment(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }

    public override void OnEnd(Activity data)
    {
        var httpContext = _httpContextAccessor.HttpContext;
        if (httpContext is null)
        {
            return;
        }

        var userName = httpContext.User?.Identity?.Name;
        if (!string.IsNullOrEmpty(userName))
        {
            data.SetTag("enduser.id", userName);
        }

        if (httpContext.Request.Headers.TryGetValue("X-Tenant-Id", out var tenantId))
        {
            data.SetTag("tenant.id", tenantId.ToString());
        }
    }
}

// Registration:
builder.Services.AddHttpContextAccessor();
builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
    tracing.AddProcessor<UserTelemetryEnrichment>());
```

--------------------------------

### Configure Application Insights with Generic Host

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/console-setup.md

Configure Application Insights telemetry within the Generic Host setup in Program.cs using `AddApplicationInsightsTelemetryWorkerService`.

```csharp
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddApplicationInsightsTelemetryWorkerService();
builder.Services.AddHostedService<MyWorker>();

var host = builder.Build();
await host.RunAsync();
```

--------------------------------

### Install Application Insights NuGet Package (.NET CLI)

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/BASE/README.md

Use this command with the .NET CLI to add the Microsoft.ApplicationInsights NuGet package to your project.

```bash
dotnet add package Microsoft.ApplicationInsights
```

--------------------------------

### Application Insights 3.x Configuration Example

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/BreakingChanges.md

This XML configuration file demonstrates the structure and available elements for configuring Application Insights in version 3.x. It replaces the older InstrumentationKey with ConnectionString and introduces new settings.

```xml
<ApplicationInsights>
  <ConnectionString>InstrumentationKey=your-key;IngestionEndpoint=https://...</ConnectionString>
  <DisableTelemetry>false</DisableTelemetry>
  <ApplicationVersion>1.0.0</ApplicationVersion>
  <SamplingRatio>1.0</SamplingRatio>
  <TracesPerSecond>5</TracesPerSecond>
  <StorageDirectory>C:\Logs</StorageDirectory>
  <DisableOfflineStorage>false</DisableOfflineStorage>
  <EnableQuickPulseMetricStream>true</EnableQuickPulseMetricStream>
  <EnableTraceBasedLogsSampler>false</EnableTraceBasedLogsSampler>
  <EnablePerformanceCounterCollectionModule>true</EnablePerformanceCounterCollectionModule>
  <AddAutoCollectedMetricExtractor>true</AddAutoCollectedMetricExtractor>
  <EnableDependencyTrackingTelemetryModule>true</EnableDependencyTrackingTelemetryModule>
  <EnableRequestTrackingTelemetryModule>true</EnableRequestTrackingTelemetryModule>
</ApplicationInsights>
```

--------------------------------

### Enrich Log Records

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/custom-processors.md

Implement a custom processor for log records to enrich them with additional attributes. This example adds a `deployment.environment` attribute to all log records processed.

```csharp
using OpenTelemetry;
using OpenTelemetry.Logs;

public class LogEnrichmentProcessor : BaseProcessor<LogRecord>
{
    public override void OnEnd(LogRecord data)
    {
        var attributes = new List<KeyValuePair<string, object?>>(data.Attributes ?? [])
        {
            new("deployment.environment", "production")
        };
        data.Attributes = attributes;
    }
}
```

--------------------------------

### Configure SQL Client Options in ASP.NET Core

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/sql-client.md

Customize SQL client instrumentation options using the DI options pattern in ASP.NET Core, Worker Service, or Web Application Insights projects. This example enables including SQL text and recording exceptions.

```csharp
using OpenTelemetry.Instrumentation.SqlClient;

builder.Services.Configure<SqlClientTraceInstrumentationOptions>(options =>
{
    options.SetDbStatementForText = true;   // Include SQL text
    options.RecordException = true;          // Record exception details on spans
});
```

--------------------------------

### Customize ASP.NET Core Request Filtering

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/NETCORE/Readme.md

Configure ASP.NET Core instrumentation to filter telemetry based on HTTP methods. This example only collects telemetry for GET requests.

```csharp
using OpenTelemetry.Instrumentation.AspNetCore;

builder.Services.AddApplicationInsightsTelemetry();

builder.Services.Configure<AspNetCoreTraceInstrumentationOptions>(options =>
{
    options.RecordException = true;
    options.Filter = (httpContext) =>
    {
        // Only collect telemetry about HTTP GET requests
        return HttpMethods.IsGet(httpContext.Request.Method);
    };
});
```

--------------------------------

### Configure HTTP Client Options

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/http-instrumentation.md

Customize HttpClientTraceInstrumentationOptions to control telemetry collection for outgoing HTTP requests. This example filters for GET requests and enriches spans with a custom header.

```csharp
using OpenTelemetry.Instrumentation.Http;
using System.Net.Http;

builder.Services.Configure<HttpClientTraceInstrumentationOptions>(options =>
{
    options.RecordException = true;
    options.FilterHttpRequestMessage = (httpRequestMessage) =>
    {
        // Only collect telemetry about HTTP GET requests
        return httpRequestMessage.Method == HttpMethod.Get;
    };
    options.EnrichWithHttpRequestMessage = (activity, httpRequestMessage) =>
    {
        if (httpRequestMessage.Headers.TryGetValues("x-request-id", out var values))
        {
            activity.SetTag("http.request.header.x-request-id", values.FirstOrDefault());
        }
    };
});
```

--------------------------------

### Customize HTTP Client Request Filtering

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/NETCORE/Readme.md

Configure HTTP client instrumentation to filter telemetry based on HTTP request methods. This example only collects telemetry for GET requests.

```csharp
using OpenTelemetry.Instrumentation.Http;

builder.Services.AddApplicationInsightsTelemetry();

builder.Services.Configure<HttpClientTraceInstrumentationOptions>(options =>
{
    options.RecordException = true;
    options.FilterHttpRequestMessage = (httpRequestMessage) =>
    {
        // Only collect telemetry about HTTP GET requests
        return HttpMethods.IsGet(httpRequestMessage.Method.Method);
    };
});
```

--------------------------------

### Install Application Insights NuGet Package (Package Manager Console)

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/BASE/README.md

Use this command in the Package Manager Console to install the Microsoft.ApplicationInsights NuGet package.

```powershell
Install-Package Microsoft.ApplicationInsights
```

--------------------------------

### SDK Version String Format

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/docs/versions_and_names.md

Illustrates the structure of the SDK version string, including optional prefix, SDK name, and semantic version.

```text
  [PREFIX_]SDKNAME:SEMVER
```

--------------------------------

### DI Scenario After (3.x)

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/aad-authentication-migration.md

In 3.x, the preferred DI approach is to set the credential directly in the AddApplicationInsightsTelemetry options.

```csharp
using Microsoft.Extensions.DependencyInjection;
using Microsoft.ApplicationInsights.AspNetCore.Extensions;
using Azure.Identity;

builder.Services.AddApplicationInsightsTelemetry(options =>
{
    options.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
    options.Credential = new DefaultAzureCredential();
});
```

--------------------------------

### Install Application Insights NuGet Package

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/aspnet-classic-greenfield.md

Use this command in the Package Manager Console to install the necessary Application Insights NuGet package for ASP.NET Classic projects.

```powershell
Install-Package Microsoft.ApplicationInsights.Web
```

--------------------------------

### Provide Dummy Connection String for Testing

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/BreakingChanges.md

In 3.x, a connection string is required. For test scenarios, a dummy string can be provided to avoid exceptions.

```csharp
InstrumentationKey=00000000-0000-0000-0000-000000000000
```

--------------------------------

### Initialize TelemetryClient in Global.asax.cs

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/WEB/Readme.md

This C# code demonstrates the recommended pattern for initializing a single TelemetryClient instance at application startup and reusing it throughout the application's lifetime. It ensures proper configuration loading and sets global properties.

```csharp
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;

public class MvcApplication : System.Web.HttpApplication
{
    public static TelemetryClient TelemetryClient { get; private set; } 
    
    protected void Application_Start()
    {
        // CreateDefault() loads configuration from ApplicationInsights.config
        var configuration = TelemetryConfiguration.CreateDefault();
        
        // Create TelemetryClient once at application startup
        TelemetryClient = new TelemetryClient(configuration);
        
        // Optionally set properties that apply to all telemetry
        TelemetryClient.Context.GlobalProperties["Environment"] = "Production";
        
        // Your other startup code
        AreaRegistration.RegisterAllAreas();
        RouteConfig.RegisterRoutes(RouteTable.Routes);
    }
    
    protected void Application_End()
    {
        // Flush telemetry before application shutdown
        TelemetryClient.Flush();
        System.Threading.Tasks.Task.Delay(1000).Wait();
    }
}
```

--------------------------------

### Configure Application Insights with Host.CreateApplicationBuilder

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/workerservice-greenfield.md

Integrate Application Insights telemetry into a Worker Service using the modern `Host.CreateApplicationBuilder` pattern in `Program.cs`.

```csharp
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddApplicationInsightsTelemetryWorkerService();
builder.Services.AddHostedService<Worker>();

var host = builder.Build();
await host.RunAsync();
```

--------------------------------

### Configure Resource with Service Info

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/opentelemetry-pipeline.md

Configure the OpenTelemetry tracer provider to set resource attributes, including service name, version, and instance ID, using Dependency Injection.

```csharp
builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
    tracing.ConfigureResource(r => r
        .AddService(
            serviceName: "MyService",
            serviceVersion: "1.0.0",
            serviceInstanceId: Environment.MachineName)));
```

--------------------------------

### Create TelemetryClient using TelemetryConfiguration

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/MigrationGuidance.md

Instantiate a TelemetryClient by passing a configured TelemetryConfiguration object. Removed constructors are no longer supported.

```csharp
var config = TelemetryConfiguration.CreateDefault();
config.ConnectionString = "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://...";
var client = new TelemetryClient(config);
```

--------------------------------

### Install Application Insights Worker Service NuGet Package

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/NETCORE/WorkerService.md

Use the .NET CLI to add the Microsoft.ApplicationInsights.WorkerService NuGet package to your project.

```dotnetcli
dotnet add package Microsoft.ApplicationInsights.WorkerService
```

--------------------------------

### 2.x Custom Telemetry Processor (HealthCheckFilter)

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/processor-migration.md

Example of a custom ITelemetryProcessor in Application Insights 2.x used to filter out health check requests.

```csharp
using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.Extensibility;

public class HealthCheckFilter : ITelemetryProcessor
{
    private readonly ITelemetryProcessor _next;

    public HealthCheckFilter(ITelemetryProcessor next)
    {
        _next = next;
    }

    public void Process(ITelemetry item)
    {
        if (item is RequestTelemetry request && request.Url.AbsolutePath == "/health")
        {
            return; // Drop health check requests
        }
        _next.Process(item);
    }
}

// Registration:
services.AddApplicationInsightsTelemetryProcessor<HealthCheckFilter>();
```

--------------------------------

### Configure HTTP Client Options via DI

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/opentelemetry-pipeline.md

Configure HTTP Client tracing instrumentation options when using Dependency Injection. Enables recording exceptions for HTTP requests.

```csharp
builder.Services.Configure<HttpClientTraceInstrumentationOptions>(options =>
{
    options.RecordException = true;
});
```

--------------------------------

### Non-DI Redis Instrumentation Setup

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/redis-cache.md

Manually configure Redis instrumentation for applications not using Dependency Injection, by passing the IConnectionMultiplexer explicitly.

```csharp
var connection = ConnectionMultiplexer.Connect("localhost:6379");

var config = TelemetryConfiguration.CreateDefault();
config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
config.ConfigureOpenTelemetryBuilder(otel =>
    otel.WithTracing(t => t.AddRedisInstrumentation(connection)));
```

--------------------------------

### Configure Telemetry Sampling and Storage

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/BASE/README.md

Configure TelemetryConfiguration with sampling ratios or traces per second, and specify settings for offline storage. Choose either SamplingRatio or TracesPerSecond, not both.

```csharp
var configuration = TelemetryConfiguration.CreateDefault();
configuration.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";

// Sampling: Choose ONE of these approaches
configuration.SamplingRatio = 0.5f;       // Keep 50% of telemetry
// configuration.TracesPerSecond = 5.0;   // OR: Keep max 5 traces/second

// Offline storage
configuration.StorageDirectory = @"C:\AppData\MyApp\Telemetry";
configuration.DisableOfflineStorage = false;

// Features
configuration.EnableLiveMetrics = true;
configuration.EnableTraceBasedLogsSampler = true;
```

--------------------------------

### Add Console Exporter

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/NETCORE/Readme.md

Add an additional exporter, such as the console exporter, to send data to multiple services. Ensure the OpenTelemetry.Exporter.Console package is installed.

```csharp
// Install: dotnet add package OpenTelemetry.Exporter.Console

builder.Services.AddApplicationInsightsTelemetry();

builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => 
{
    builder.AddConsoleExporter();
});
```

--------------------------------

### Add gRPC Client Instrumentation

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/NETCORE/Readme.md

Add additional instrumentation for gRPC client calls by installing the OpenTelemetry.Instrumentation.GrpcNetClient package and configuring the Tracer Provider.

```csharp
// Install: dotnet add package OpenTelemetry.Instrumentation.GrpcNetClient

builder.Services.AddApplicationInsightsTelemetry();

builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => 
{
    builder.AddGrpcClientInstrumentation();
});
```

--------------------------------

### Configure ASP.NET Core Server Options via DI

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/opentelemetry-pipeline.md

Configure ASP.NET Core server tracing instrumentation options when using Dependency Injection. Enables recording exceptions for incoming requests.

```csharp
builder.Services.Configure<AspNetCoreTraceInstrumentationOptions>(options =>
{
    options.RecordException = true;
});
```

--------------------------------

### 3.x Custom Log Enrichment Processor

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/processor-migration.md

Example of a custom BaseProcessor<LogRecord> in Application Insights 3.x for enriching log records with custom attributes.

```csharp
public class LogEnrichmentProcessor : BaseProcessor<LogRecord>
{
    public override void OnEnd(LogRecord data)
    {
        var attributes = new List<KeyValuePair<string, object?>>(data.Attributes ?? [])
        {
            new("deployment.environment", "production")
        };
        data.Attributes = attributes;
    }
}

// Registration (DI):
builder.Services.ConfigureOpenTelemetryLoggerProvider(logging =>
    logging.AddProcessor<LogEnrichmentProcessor>());

// Registration (Non-DI):
config.ConfigureOpenTelemetryBuilder(otel =>
    otel.WithLogging(l => l.AddProcessor<LogEnrichmentProcessor>()));
```

--------------------------------

### Configure Azure AD Authentication in Global.asax.cs

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/WEB/Src/Web/README.md

Set up Azure Active Directory authentication in your web application's Global.asax.cs file. This requires the `Azure.Identity` NuGet package.

```csharp
using Microsoft.ApplicationInsights.Extensibility;
using Azure.Identity;

public class Global : HttpApplication
{
    void Application_Start(object sender, EventArgs e)
    {
        var telemetryConfig = TelemetryConfiguration.CreateDefault();
        telemetryConfig.ConnectionString = "InstrumentationKey=YOUR_IKEY;IngestionEndpoint=https://ingestion-endpoint.applicationinsights.azure.com/";
        telemetryConfig.SetAzureTokenCredential(new DefaultAzureCredential());
    }
}
```

--------------------------------

### Configure Sampling via Environment Variables (3.x)

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/sampling-migration.md

Set Application Insights sampling using environment variables. Use `OTEL_TRACES_SAMPLER` and `OTEL_TRACES_SAMPLER_ARG` for rate-limited or fixed-percentage sampling.

```bash
# Rate-limited:
OTEL_TRACES_SAMPLER=microsoft.rate_limited
OTEL_TRACES_SAMPLER_ARG=10
```

```bash
# Fixed percentage:
OTEL_TRACES_SAMPLER=microsoft.fixed_percentage
OTEL_TRACES_SAMPLER_ARG=0.5
```

--------------------------------

### Create Default TelemetryConfiguration

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/MigrationGuidance.md

Use TelemetryConfiguration.CreateDefault() for creating a telemetry configuration in v3.x. This is the recommended approach.

```csharp
TelemetryConfiguration.CreateDefault()
```

--------------------------------

### 3.x Non-DI Registration for TelemetryConfiguration

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/processor-migration.md

Example of registering a custom processor using TelemetryConfiguration directly for console or classic ASP.NET applications in Application Insights 3.x.

```csharp
var config = TelemetryConfiguration.CreateDefault();
config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
config.ConfigureOpenTelemetryBuilder(otel =>
    otel.WithTracing(t => t.AddProcessor<HealthCheckFilterProcessor>()));
```

--------------------------------

### Enable Application Insights with Configuration

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/NETCORE/Readme.md

Integrate Application Insights by passing the IConfiguration to AddApplicationInsightsTelemetry(), with the connection string defined in appsettings.json.

```csharp
var builder = WebApplication.CreateBuilder(args);

// Add Application Insights telemetry from configuration
builder.Services.AddApplicationInsightsTelemetry(builder.Configuration);

// Add other services for your application
builder.Services.AddMvc();

var app = builder.Build();
```

--------------------------------

### Configure OpenTelemetry Integration

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/BASE/README.md

Extend the SDK using OpenTelemetry's builder pattern to add custom ActivitySources or processors. Avoid setting an OpenTelemetry Sampler directly via builder.SetSampler().

```csharp
configuration.ConfigureOpenTelemetryBuilder(builder =>
{
    // Add custom ActivitySources (explained below)
    builder.WithTracing(tracing => tracing.AddSource("MyApp.*"));
    
    // Add processors
    builder.WithTracing(tracing => tracing.AddProcessor<CustomEnrichmentProcessor>());
});
```

--------------------------------

### Enable ETW Provider

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/troubleshooting/ETW/Readme.md

This code snippet demonstrates how to enable an ETW provider by its name using the TraceEventSession class. This is useful for looking up provider GUIDs at runtime.

```csharp
var session = new TraceEventSession("test");
session.EnableProvider(providerName: "Microsoft-ApplicationInsights-Core");
```

--------------------------------

### Configure OpenTelemetry Resource in DI

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/MigrationGuidance.md

Configure the OpenTelemetry Resource via the OpenTelemetry builder in Dependency Injection scenarios. This is necessary because the SDK builds the OpenTelemetry SDK before user code runs, preventing Context.Cloud setters from influencing the Resource in time.

```csharp
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, tracerBuilder) =>
{
    tracerBuilder.ConfigureResource(r => r
        .AddService(
            serviceName: "MyRoleName",                   // Maps to Cloud.RoleName
            serviceInstanceId: Environment.MachineName,  // Maps to Cloud.RoleInstance
            serviceVersion: "1.0.0")                     // Maps to Component.Version
    );
});

builder.Services.ConfigureOpenTelemetryLoggerProvider((sp, loggerBuilder) =>
{
    loggerBuilder.ConfigureResource(r => r
        .AddService(
            serviceName: "MyRoleName",                   // Maps to Cloud.RoleName
            serviceInstanceId: Environment.MachineName,  // Maps to Cloud.RoleInstance
            serviceVersion: "1.0.0")                     // Maps to Component.Version
    );
});
```

--------------------------------

### Registering TelemetryConfiguration and TelemetryClient

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/BASE/README.md

Register TelemetryConfiguration and TelemetryClient as singletons within the service collection. Ensure your connection string is correctly configured.

```csharp
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();

// Register TelemetryConfiguration
services.AddSingleton(sp =>
{
    var config = TelemetryConfiguration.CreateDefault();
    config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
    
    return config;
});

// Register TelemetryClient
services.AddSingleton<TelemetryClient>(sp =>
{
    var config = sp.GetRequiredService<TelemetryConfiguration>();
    return new TelemetryClient(config);
});

// Inject into your services
public class OrderService
{
    private readonly TelemetryClient _telemetryClient;
    
    public OrderService(TelemetryClient telemetryClient)
    {
        _telemetryClient = telemetryClient;
    }
    
    public void ProcessOrder(string orderId)
    {
        _telemetryClient.TrackEvent("OrderProcessed", new Dictionary<string, string>
        {
            { "OrderId", orderId }
        });
    }
}
```

--------------------------------

### 3.x Custom Telemetry Processor (HealthCheckFilterProcessor)

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/skills/applicationinsights-setup/references/processor-migration.md

Example of a custom BaseProcessor<Activity> in Application Insights 3.x for filtering health check requests by dropping them using the Recorded flag.

```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;
        }
    }
}

// Registration:
builder.Services.ConfigureOpenTelemetryTracerProvider(tracing =>
    tracing.AddProcessor<HealthCheckFilterProcessor>());
```

--------------------------------

### Custom Log Processor for Enrichment

Source: https://github.com/microsoft/applicationinsights-dotnet/blob/main/docs/concepts.md

Implement a custom Log Processor to enrich log-based telemetry, such as exceptions, traces, and custom events. This example adds an 'app.environment' attribute.

```csharp
using OpenTelemetry;
using OpenTelemetry.Logs;

public class CustomLogProcessor : BaseProcessor<LogRecord>
{
    public override void OnEnd(LogRecord logRecord)
        {
            var attributes = new List<KeyValuePair<string, object?>> 
            {
                new("app.environment", "Production"),
            };

            if (logRecord.Attributes != null)
            {
                attributes.AddRange(logRecord.Attributes);
            }

            logRecord.Attributes = attributes;
        }
}
```