Overview

Application Insights is a powerful tool provided by Microsoft Azure, designed to monitor and analyze the performance of web applications. It collects telemetry data, providing insights into how applications are performing in real-world scenarios. This integration is crucial for developers and businesses that aim to maintain high-quality applications, as it enables proactive identification and resolution of performance issues before they affect end-users.

The primary purpose of Application Insights is to offer a comprehensive view of application health and usage through automatic monitoring. This includes tracking request rates, response times, failure rates, and user interactions. By leveraging these insights, developers can make informed decisions to enhance application performance, improve user experiences, and optimize resource usage. Real-world use cases include monitoring e-commerce websites for transaction performance, analyzing API response times, and assessing user engagement in SaaS applications.

Prerequisites

• ASP.NET Core knowledge: Familiarity with ASP.NET Core project structure and middleware.
• Azure account: An active Azure subscription to access Application Insights features.
• Visual Studio: Recommended IDE for developing and testing ASP.NET Core applications.
• NuGet Package Manager: Ability to install necessary packages from NuGet.

Setting Up Application Insights

To integrate Application Insights into an ASP.NET Core application, the first step is to set up an Application Insights resource in the Azure portal. This resource will serve as the endpoint for telemetry data collected from your application. The Azure portal provides a straightforward interface to create a new Application Insights resource, where you can select your preferred region and pricing tier.

Once the resource is created, you will receive an Instrumentation Key or Connection String. This key will be used to configure the Application Insights SDK in your ASP.NET Core application, enabling it to send telemetry data to the Azure service.

public void ConfigureServices(IServiceCollection services)
{
    services.AddApplicationInsightsTelemetry("YOUR_INSTRUMENTATION_KEY");
}

This code snippet is added in the ConfigureServices method of the Startup.cs file. Here's a breakdown of what happens:

• services.AddApplicationInsightsTelemetry: This method registers the Application Insights services with the ASP.NET Core dependency injection container.
• "YOUR_INSTRUMENTATION_KEY": Replace this string with the actual Instrumentation Key obtained from the Azure portal.

Using Connection String

As of recent updates, Microsoft encourages the use of connection strings instead of Instrumentation Keys for better security and flexibility. The connection string includes the instrumentation key and other configuration settings.

public void ConfigureServices(IServiceCollection services)
{
    services.AddApplicationInsightsTelemetry(Configuration["ApplicationInsights:ConnectionString"]);
}

This code retrieves the connection string from the application configuration settings, allowing for easier management and deployment across multiple environments.

Telemetry Data Collection

Once Application Insights is set up, the next step is to collect telemetry data. Application Insights provides several built-in telemetry types, including requests, exceptions, and custom events. By default, ASP.NET Core applications automatically track requests and exceptions.

To extend telemetry collection, you can use the TelemetryClient class. This class allows you to send custom events, metrics, and traces to Application Insights, providing deeper insights into application behavior.

public class HomeController : Controller
{
    private readonly TelemetryClient _telemetryClient;

    public HomeController(TelemetryClient telemetryClient)
    {
        _telemetryClient = telemetryClient;
    }

    public IActionResult Index()
    {
        _telemetryClient.TrackEvent("IndexPageVisited");
        return View();
    }
}

In this example, the HomeController uses dependency injection to obtain an instance of TelemetryClient. Here’s what the code does:

• TelemetryClient: A service that allows sending telemetry data to Application Insights.
• TrackEvent: This method logs a custom event when the index page is visited, enabling you to analyze user behavior.

Custom Metrics

Besides tracking events, you can also track custom metrics to monitor application performance. Custom metrics can provide insights into specific application behaviors and help in performance optimization.

public IActionResult ProcessData()
{
    var watch = Stopwatch.StartNew();
    // Simulate data processing
    Thread.Sleep(100);
    watch.Stop();
    _telemetryClient.TrackMetric("DataProcessingTime", watch.ElapsedMilliseconds);
    return Ok();
}

This method simulates data processing and tracks the time taken. The breakdown is as follows:

• Stopwatch: Used to measure the duration of the data processing task.
• TrackMetric: Logs the time taken to process data as a custom metric, which can be analyzed in Application Insights.

Advanced Telemetry Configuration

Application Insights provides a variety of configuration options to fine-tune telemetry collection. You can control what telemetry is sent, filter out unnecessary data, and customize the telemetry context. The TelemetryProcessor interface allows you to create custom processors that can modify or filter telemetry data before it is sent.

public class ExcludeTelemetryProcessor : ITelemetryProcessor
{
    private ITelemetryProcessor _next;

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

    public void Process(ITelemetry item)
    {
        // Exclude telemetry based on certain conditions
        if (item is RequestTelemetry request && request.Url.ToString().Contains("/exclude"))
        {
            return; // Skip sending this telemetry
        }
        _next.Process(item);
    }
}

This custom telemetry processor filters out telemetry for requests containing the path "exclude". The explanation is as follows:

• ITelemetryProcessor: Interface for creating telemetry processors.
• Process method: Logic to decide whether to send or filter out telemetry based on the request URL.

Edge Cases & Gotchas

When implementing Application Insights, developers may encounter several common pitfalls. One such issue is not properly configuring the instrumentation key or connection string, leading to telemetry data not being sent. Ensure that the key is correct and that the Application Insights resource is accessible from your application.

Another common mistake is overloading the telemetry system with excessive custom events and metrics, which can lead to higher costs and performance degradation. It's essential to strike a balance between monitoring needs and performance impacts.

// Incorrect approach: Sending too many events
for (int i = 0; i < 10000; i++)
{
    _telemetryClient.TrackEvent("HighFrequencyEvent");
}

The above code sends a large number of events in a short time, which can overwhelm Application Insights. A better approach would involve aggregating events and sending them in batches or only when significant thresholds are met.

Performance & Best Practices

To optimize the performance of Application Insights in your ASP.NET Core applications, consider the following best practices:

• Limit Telemetry Size: Reduce the amount of data sent by omitting unnecessary properties and using sampling techniques.
• Asynchronous Telemetry: Use asynchronous methods for sending telemetry to avoid blocking the main application thread.
• Telemetry Sampling: Implement sampling to capture a representative subset of events, which can drastically reduce the amount of telemetry data sent.

services.AddApplicationInsightsTelemetry(options =>
{
    options.EnableAdaptiveSampling = true;
});

This code snippet enables adaptive sampling, which automatically adjusts the rate of telemetry data sent based on the application's load. This helps maintain performance while still providing valuable insights.

Real-World Scenario: E-Commerce Application Monitoring

To illustrate the concepts discussed, consider a simple e-commerce application that tracks user interactions, product view times, and transaction performance using Application Insights. The application will consist of a few endpoints that demonstrate telemetry data collection.

public class ProductsController : Controller
{
    private readonly TelemetryClient _telemetryClient;

    public ProductsController(TelemetryClient telemetryClient)
    {
        _telemetryClient = telemetryClient;
    }

    public IActionResult ViewProduct(int id)
    {
        _telemetryClient.TrackEvent("ProductViewed", new Dictionary { { "ProductId", id.ToString() } });
        // Simulate product view
        return View();
    }

    public IActionResult Purchase(int productId)
    {
        var watch = Stopwatch.StartNew();
        // Simulate purchase processing
        Thread.Sleep(200);
        watch.Stop();
        _telemetryClient.TrackMetric("PurchaseTime", watch.ElapsedMilliseconds);
        return Ok();
    }
}

In this scenario:

• ViewProduct method: Tracks when a product is viewed, logging a custom event with the product ID.
• Purchase method: Measures the time taken to process a purchase and logs it as a custom metric.

Conclusion

• Application Insights provides essential monitoring and telemetry capabilities for ASP.NET Core applications.
• Understanding how to integrate and configure Application Insights can lead to significant improvements in application performance and user experience.
• Utilizing custom events and metrics helps developers gain deeper insights into application behavior.
• Implementing best practices ensures efficient use of resources and cost management.