Application Insights

Application Insights is an extensible Application Performance Management (APM) service for developers and DevOps professionals. It automatically detects performance anomalies, includes powerful analytics tools, and integrates with Visual Studio and Azure DevOps. It helps you continuously improve performance and usability.

Application Insights instruments your application by collecting telemetry data: requests, dependencies, exceptions, traces, page views, and custom events. The instrumentation can be done via: - Auto-instrumentation: For Azure App Services, VMs, and on-premises via Application Insights Agent (formerly Status Monitor). No code changes required. - SDK: For .NET, Java, Node.js, Python, JavaScript, and others. Provides full control over telemetry. - OpenTelemetry: A vendor-neutral standard that can export to Application Insights.

#### Instrumentation Key (iKey) - A GUID that identifies your Application Insights resource. - Required for sending telemetry. - Can be stored in configuration files or environment variables.

#### Telemetry Types - Request: Incoming HTTP requests. Default: collected automatically for ASP.NET, ASP.NET Core, and Java. - Dependency: Outbound calls to SQL, HTTP, Azure services. Default: collected for ADO.NET, HTTP clients, Azure SDK. - Exception: Caught and uncaught exceptions. Default: collected automatically. - Trace: Log statements (e.g., using ILogger). Requires SDK configuration. - Custom Event: Business events (e.g., "OrderPlaced"). Requires manual tracking. - Page View: Client-side page loads (JavaScript SDK). - Metric: Numeric values (e.g., queue length). - Availability: Web tests that ping your endpoints.

#### Sampling - Adaptive Sampling: Automatically adjusts telemetry volume to stay under a configured maximum rate (default: 5 events per second for ASP.NET). - Fixed-rate Sampling: You set a percentage (e.g., 10%). - Ingestion Sampling: At the backend, if your data rate exceeds the pricing tier.

#### Retention - Default: 90 days for logs and metrics. - Continuous export: To Azure Storage for longer retention (up to 90 days per export). - Log Analytics workspace: Can retain up to 2 years with appropriate pricing tier.

#### Setting up Application Insights in an ASP.NET Core app

// In Program.cs
builder.Services.AddApplicationInsightsTelemetry();

#### Configuring the Instrumentation Key

// appsettings.json
{
  "ApplicationInsights": {
    "InstrumentationKey": "your-ikey"
  }
}

#### Verifying telemetry is flowing - Use the Application Insights blade in Azure portal. - Navigate to "Live Metrics" to see real-time data. - Query using Log Analytics:

requests | where timestamp > ago(1h) | count

Application Insights automatically analyzes telemetry and alerts you about:

For microservices, Application Insights correlates telemetry using: - Operation ID: Links all events for a single user request across services. - Parent ID: Establishes the hierarchy of calls. - W3C Trace-Context: Standard format for distributed tracing.

using Microsoft.ApplicationInsights;

TelemetryClient telemetry = new TelemetryClient();
telemetry.Context.InstrumentationKey = "your-ikey";
telemetry.TrackEvent("OrderPlaced", new Dictionary<string, string> { {"OrderId", "123"} });

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

A large e-commerce company uses Application Insights to monitor their ASP.NET Core microservices. They instrument each service with the SDK and use distributed tracing to correlate requests across services. The operations team has set up metric alerts for high response times (> 2 seconds) and failure rates (> 1%). They use the Application Map to visualize dependencies and identify bottlenecks, such as a slow SQL database. They also track custom events like 'CheckoutStarted' and 'PaymentFailed' to monitor business KPIs. In production, they handle 10,000 requests per second and use adaptive sampling to keep costs manageable. A common issue is misconfigured sampling causing missing data for low-volume endpoints. They solved this by using fixed-rate sampling for critical endpoints.

A SaaS provider uses Application Insights to understand user behavior and diagnose issues. They instrument the frontend with the JavaScript SDK to collect page views and custom events. They use the Usage analysis features to build funnels and retention reports. They also use availability tests to monitor uptime across multiple regions. A challenge they faced was high data ingestion costs due to verbose trace logging. They implemented fixed-rate sampling at 10% for traces and used the Log Analytics workspace to retain data for 90 days. They also set up continuous export to Azure Blob Storage for compliance. A common misconfiguration is forgetting to set the Instrumentation Key in production, resulting in no telemetry. They use Azure Key Vault to securely store the key.

An IoT company monitors their Azure Functions backend using Application Insights. They use the built-in integration with Azure Functions – simply enabling Application Insights in the Function App settings. They collect telemetry for each function invocation, including bindings and dependencies. They use custom metrics to track device telemetry ingestion rates and error counts. They set up alerts for function failures and cold start delays. A common issue is 'sampling not applied to custom events' – they had to explicitly set sampling for custom telemetry. They also use Log Analytics queries to correlate device errors with backend exceptions. They export data to Power BI for executive dashboards.