Application Insights Setup

Overview

Application Insights is the Application Performance Management (APM) component of Azure Monitor. It provides real-time telemetry for your live applications — tracking requests, dependencies, exceptions, traces, and custom events.

Connection Strings vs Instrumentation Keys

The connection string is the modern, recommended way to connect your app to Application Insights. It replaces the legacy instrumentation key approach and supports regional endpoints.

InstrumentationKey=<guid>;IngestionEndpoint=https://eastus-0.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/

⚠️ Instrumentation keys are deprecated. Always use connection strings for new projects.

SDK Configuration (.NET)

Install the NuGet Package

dotnet add package Microsoft.ApplicationInsights.AspNetCore

Configure in Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add Application Insights telemetry
builder.Services.AddApplicationInsightsTelemetry(options =>
{
    options.ConnectionString = builder.Configuration["ApplicationInsights:ConnectionString"];
});

var app = builder.Build();

appsettings.json

{
  "ApplicationInsights": {
    "ConnectionString": "InstrumentationKey=xxx;IngestionEndpoint=https://eastus-0.in.applicationinsights.azure.com/"
  }
}

Auto-Instrumentation (Codeless)

For Azure App Service, you can enable Application Insights without code changes:

1. Navigate to your App Service in the Azure Portal
2. Go to Settings → Application Insights
3. Click Turn on Application Insights
4. Select your Application Insights resource
5. Choose the appropriate SDK version

Auto-instrumentation automatically collects:

• HTTP requests and response times
• Dependency calls (SQL, HTTP, Azure Storage)
• Exceptions and stack traces
• Performance counters

Node.js / JavaScript SDK

npm install applicationinsights

const appInsights = require("applicationinsights");

appInsights.setup(process.env.APPLICATIONINSIGHTS_CONNECTION_STRING)
  .setAutoCollectRequests(true)
  .setAutoCollectPerformance(true)
  .setAutoCollectExceptions(true)
  .setAutoCollectDependencies(true)
  .setAutoCollectConsole(true, true)
  .start();

💡 Place this at the very top of your entry file, before any other imports.

Azure Functions Integration

For .NET Isolated Worker:

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .ConfigureServices(services =>
    {
        services.AddApplicationInsightsTelemetryWorkerService();
        services.ConfigureFunctionsApplicationInsights();
    })
    .Build();

Set the connection string in local.settings.json:

{
  "Values": {
    "APPLICATIONINSIGHTS_CONNECTION_STRING": "InstrumentationKey=..."
  }
}

Sampling Configuration

Sampling reduces telemetry volume and cost without losing statistical accuracy:

builder.Services.AddApplicationInsightsTelemetry(options =>
{
    options.ConnectionString = connectionString;
    options.EnableAdaptiveSampling = true;
});

// Or configure sampling explicitly
builder.Services.Configure<TelemetryConfiguration>(telemetryConfig =>
{
    var processorChainBuilder = telemetryConfig.DefaultTelemetrySink.TelemetryProcessorChainBuilder;
    processorChainBuilder.UseAdaptiveSampling(maxTelemetryItemsPerSecond: 5);
    processorChainBuilder.Build();
});

Best Practices

1. Use connection strings — Never hardcode them; use Key Vault or app settings
2. Enable adaptive sampling — Prevents cost overruns in high-traffic apps
3. Set cloud role name — Distinguishes services in Application Map

// CloudRoleNameInitializer is a custom class you must create
public class CloudRoleNameInitializer : ITelemetryInitializer
{
    private readonly string _roleName;
    public CloudRoleNameInitializer(string roleName) => _roleName = roleName;
    public void Initialize(ITelemetry telemetry) => telemetry.Context.Cloud.RoleName = _roleName;
}

// Register in DI
services.AddApplicationInsightsTelemetry();
services.AddSingleton<ITelemetryInitializer>(new CloudRoleNameInitializer("OrderService"));

4. Filter sensitive data — Use telemetry initializers to redact PII
5. Use Managed Identity — For workspace-based Application Insights, authenticate with DefaultAzureCredential
6. Monitor ingestion latency — Typical delay is 2-5 minutes; don't expect real-time for log queries

Verifying Setup

After deployment, verify telemetry is flowing:

1. Open Application Insights in the portal
2. Check Live Metrics for real-time data
3. Run a test request and confirm it appears in Transaction Search
4. Check Failures blade for any SDK initialization errors

Key Takeaways

• Application Insights is the APM layer of Azure Monitor
• Connection strings are the modern authentication method
• Auto-instrumentation works for App Service without code changes
• SDK gives you full control over what telemetry is collected
• Sampling is essential for cost management in production