Microsoft Azure — Application Insights

Azure is Microsoft's cloud computing platform offering over 200 services. This article covers application insights with production-ready configurations, best practices, and hands-on examples.

Why Application Insights Exists

Application Insights is Microsoft's application performance management (APM) service for live web applications. It automatically detects performance anomalies, includes powerful analytics tools, and integrates with Azure DevOps for continuous improvement. Unlike basic logging, it provides distributed tracing, dependency mapping, and smart detection of failures. For production systems, it's the difference between knowing something is wrong and knowing exactly why. If you're not using it, you're flying blind.

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddApplicationInsightsTelemetry();

var app = builder.Build();

app.MapGet("/", async (TelemetryClient telemetry) =>
{
    using var operation = telemetry.StartOperation<RequestTelemetry>("HomePage");
    operation.Telemetry.ResponseCode = "200";
    operation.Telemetry.Success = true;
    return Results.Ok("Hello, World!");
});

app.Run();

Setting Up the Instrumentation Key

Every Application Insights resource has an instrumentation key (ikey) that identifies your app. You can store it in appsettings.json, environment variables, or Azure Key Vault. Never hardcode it. Use the connection string instead of the ikey for better security and regional routing. The connection string includes the ikey and the endpoint suffix. For production, rotate keys periodically and use managed identities to avoid secrets altogether.

{
  "ApplicationInsights": {
    "ConnectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westus2-0.in.applicationinsights.azure.com/;LiveEndpoint=https://westus2.livediagnostics.monitor.azure.com/"
  }
}

Sampling: Balancing Cost and Fidelity

In high-traffic production systems, sending every telemetry event can be expensive and noisy. Application Insights supports sampling: adaptive, fixed-rate, and ingestion sampling. Adaptive sampling automatically adjusts the rate based on traffic, preserving the most interesting events (errors, slow requests). Fixed-rate sampling is simpler but can miss rare events. Ingestion sampling happens at the backend and can't be undone. For most production apps, start with adaptive sampling at 10-20% and monitor the impact on alerting.

using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel;

var builder = WebApplication.CreateBuilder(args);

builder.Services.Configure<TelemetryConfiguration>((config) =>
{
    var sampling = new AdaptiveSamplingTelemetryProcessor(new DefaultTelemetryProcessor(config));
    config.TelemetryProcessorChainBuilder.Use(sampling);
    config.TelemetryProcessorChainBuilder.Build();
});

builder.Services.AddApplicationInsightsTelemetry();

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

Distributed Tracing Across Services

Modern applications are distributed across microservices, queues, and databases. Application Insights correlates telemetry across these components using the W3C Trace-Context standard. Each request gets a unique trace ID that propagates via HTTP headers. This allows you to see the full end-to-end flow, including dependencies like SQL, Redis, and HTTP calls. Without distributed tracing, you can't diagnose latency issues that span multiple services.

using System.Net.Http;
using Microsoft.ApplicationInsights;

public class MyService
{
    private readonly HttpClient _httpClient;
    private readonly TelemetryClient _telemetry;

    public MyService(HttpClient httpClient, TelemetryClient telemetry)
    {
        _httpClient = httpClient;
        _telemetry = telemetry;
    }

    public async Task<string> CallDownstreamAsync()
    {
        using var operation = _telemetry.StartOperation<DependencyTelemetry>("DownstreamCall");
        operation.Telemetry.Type = "HTTP";
        operation.Telemetry.Target = "downstream-api.example.com";
        
        var response = await _httpClient.GetAsync("https://downstream-api.example.com/data");
        operation.Telemetry.Success = response.IsSuccessStatusCode;
        operation.Telemetry.Duration = DateTimeOffset.UtcNow - operation.Telemetry.Timestamp;
        
        return await response.Content.ReadAsStringAsync();
    }
}

Custom Events and Metrics for Business Insights

Beyond technical metrics, track business events like user sign-ups, orders, or feature usage. Use TrackEvent for custom events and TrackMetric for numeric values. This data can be analyzed in the Azure portal or exported to Power BI. Be careful not to send personally identifiable information (PII) — Application Insights is not a data warehouse. Use properties to add context like user ID (hashed) or experiment variant.

public class OrderService
{
    private readonly TelemetryClient _telemetry;

    public OrderService(TelemetryClient telemetry)
    {
        _telemetry = telemetry;
    }

    public async Task PlaceOrder(Order order)
    {
        // Business logic
        
        _telemetry.TrackEvent("OrderPlaced", new Dictionary<string, string>
        {
            { "Currency", order.Currency },
            { "UserId", order.UserId.GetHashCode().ToString() } // Hashed, not raw
        }, new Dictionary<string, double>
        {
            { "OrderValue", order.Total }
        });
    }
}

Logging with Application Insights

Application Insights integrates with ILogger in .NET, allowing you to send logs directly. Configure log levels to control verbosity. In production, set the minimum log level to Warning to avoid flooding. Use structured logging with placeholders for better querying. The SDK automatically correlates logs with the current request trace, so you can see logs in context.

var builder = WebApplication.CreateBuilder(args);

builder.Logging.AddApplicationInsights(
    configureTelemetryConfiguration: (config) => 
        config.ConnectionString = builder.Configuration["ApplicationInsights:ConnectionString"],
    configureApplicationInsightsLoggerOptions: (options) => { }
);

builder.Services.AddApplicationInsightsTelemetry();

var app = builder.Build();

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogInformation("Home page visited at {Time}", DateTime.UtcNow);
    return "Hello";
});

app.Run();

Alerts and Smart Detection

Application Insights can proactively alert you on failures, performance degradation, and anomalies. Smart Detection automatically analyzes telemetry and alerts on patterns like failed requests, memory leaks, and dependency issues. Set up metric alerts for critical thresholds (e.g., failure rate > 5%). Use log alerts for complex conditions. Avoid alert fatigue by tuning thresholds and using action groups for on-call rotation.

{
  "properties": {
    "name": "High Failure Rate",
    "description": "Alert when failure rate exceeds 5% over 5 minutes",
    "severity": 1,
    "enabled": true,
    "scopes": ["/subscriptions/.../components/MyApp"],
    "evaluationFrequency": "PT5M",
    "windowSize": "PT5M",
    "criteria": {
      "metricName": "requests/failed",
      "metricNamespace": "microsoft.insights/components",
      "operator": "GreaterThan",
      "threshold": 5,
      "timeAggregation": "Total"
    },
    "actions": {
      "actionGroups": ["/subscriptions/.../actionGroups/OnCall"]
    }
  }
}

Querying Telemetry with Analytics

Application Insights uses Kusto Query Language (KQL) for deep analysis. You can query requests, dependencies, traces, and custom events. Use the Azure portal's Logs blade or export to Power BI. Common queries: find slowest endpoints, error breakdowns, user funnel analysis. KQL is powerful but has a learning curve. Start with the built-in templates and modify them.

requests
| where timestamp > ago(1h)
| summarize avg(duration) by name, url
| order by avg_duration desc
| take 10

Continuous Export and Integration

For long-term retention or custom processing, export telemetry to Azure Storage, Event Hubs, or Log Analytics. Continuous Export sends raw data to blob storage. For real-time streaming, use Event Hubs with Azure Functions or Stream Analytics. This is useful for feeding data into a SIEM or custom dashboard. Be aware of costs: exporting all data can be expensive.

{
  "properties": {
    "destination": {
      "storageAccountId": "/subscriptions/.../storageAccounts/...",
      "containerName": "appinsights-export"
    },
    "recordTypes": ["Request", "Dependency", "Exception", "Event", "Trace"],
    "isEnabled": true
  }
}

Performance Testing with Application Insights

Application Insights can monitor load tests by correlating test runs with telemetry. Use Azure Load Testing or Visual Studio load tests with the Application Insights SDK. Track test-specific metrics like requests per second and error rate. Compare performance across builds to catch regressions. This is essential for capacity planning and SLA compliance.

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;

public class LoadTestTracker
{
    private readonly TelemetryClient _telemetry;

    public LoadTestTracker(TelemetryClient telemetry)
    {
        _telemetry = telemetry;
    }

    public void TrackTestRun(string testName, int users, double avgResponseTime)
    {
        _telemetry.TrackEvent("LoadTestRun", new Dictionary<string, string>
        {
            { "TestName", testName },
            { "Users", users.ToString() }
        }, new Dictionary<string, double>
        {
            { "AvgResponseTime", avgResponseTime }
        });
    }
}

Troubleshooting Common Production Issues

Common issues include missing telemetry, high latency, and sampling bias. Missing telemetry often results from incorrect connection strings or firewall blocks. High latency can be caused by slow dependencies or inefficient code. Sampling bias can hide intermittent errors. Use the Application Insights troubleshooting guide: check the live metrics stream, verify SDK version, and review the telemetry processor chain.

public static void CheckTelemetry(TelemetryClient telemetry)
{
    // Force flush to ensure data is sent
    telemetry.Flush();
    Task.Delay(5000).Wait(); // Allow time for sending
    
    // Check if telemetry is being sent
    Console.WriteLine("Telemetry flushed. Check Azure portal for data.");
}

Cost Management and Optimization

Application Insights pricing is based on data ingested and retention. To control costs: use sampling, set daily caps, and filter out noisy telemetry. Use the Pricing Tier to choose between Pay-as-you-go and Enterprise (per node). Monitor your daily usage in the portal. Set alerts for approaching the daily cap to avoid data loss. Consider moving old data to cheaper storage via Continuous Export.

{
  "properties": {
    "dailyDataCapInGB": 10,
    "dailyDataCapStopSendNotification": true,
    "stopSendNotificationWhenHitCap": true
  }
}