ASP.NET Core Application Insights Step by step Implementation and Top 10 Questions and Answers

Last Update: April 01, 2025 17 mins read Difficulty-Level: beginner

Understanding ASP.NET Core Application Insights

ASP.NET Core Application Insights is a feature-rich diagnostic and monitoring tool designed by Microsoft to help developers gain insights into the performance and health of their web applications. This tool is seamlessly integrated with the ASP.NET Core framework and provides comprehensive monitoring capabilities, real-time diagnostics, analytics, and logging. In this article, we'll explore the details and significance of using Application Insights in ASP.NET Core applications.

1. What is Application Insights?

Application Insights is a fully managed Application Performance Management (APM) service that monitors your live web applications. It helps you diagnose and fix issues proactively, and improve the performance of your applications. It captures detailed telemetry data from your applications and presents it in a user-friendly dashboard, enabling developers to make informed decisions.

2. Key Features of Application Insights

Telemetry Collection: Application Insights automatically collects telemetry data about how users interact with your application, including page views, requests, and exceptions.
Performance Monitoring: It provides metrics related to application performance, such as response time, request counts, and failed requests.
Error Logging: Application Insights aggregates and categorizes application errors, providing actionable insights into issues.
Analytics and Visualization: It provides powerful analytics and visualization tools that allow developers to analyze telemetry data and identify trends.
User Flow Analysis: Application Insights tracks user flows across web pages and identifies areas where users might drop off or encounter issues.
Real-Time Monitoring: It provides real-time monitoring capabilities, allowing developers to detect anomalies and diagnose issues quickly.
Availability Tests: It can perform web tests to check the availability and response time of your application continuously.
Custom Telemetry: Developers can write custom code to collect additional telemetry data.

3. Setting Up Application Insights in ASP.NET Core

Setting up Application Insights in an ASP.NET Core application is straightforward and typically involves a few simple steps:

Create an Application Insights Resource:
- In the Azure portal, create a new Application Insights resource.
- Once created, you'll receive an Instrumentation Key that is crucial for connecting your application to the Application Insights service.
Install the Application Insights SDK:
- Add the Microsoft.ApplicationInsights.AspNetCore NuGet package to your project.

Configure Application Insights:

In the Program.cs file, add the following code to configure Application Insights with the Instrumentation Key:

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddApplicationInsightsTelemetry(builder.Configuration["InstrumentationKey"]);

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Optional Configuration:
- You can further customize the behavior of Application Insights by using the Startup.cs file to configure custom telemetry modules, initializers, and processors.

4. Using Application Insights

Once Application Insights is set up, you can start leveraging its features to gain insights into your application:

Dashboard Overview: The Overview dashboard provides a high-level summary of your application's health, including performance metrics, top issues, and user flows.
Performance Metrics: The Performance Metrics page displays detailed metrics about your application's performance, such as request counts, failed requests, and response times.
Failures: The Failures page tracks and categorizes application errors, providing actionable insights into issues.
Analytics: The Analytics blade provides a powerful query language called Kusto that allows you to query and analyze raw telemetry data.
Availability: The Availability page displays the results of web tests, showing the availability and response time of your application over time.

5. Customizing Telemetry

Application Insights allows you to customize the telemetry data collected by writing custom code. Here are a few ways to customize telemetry:

Custom Metrics: You can log custom metrics by using the TelemetryClient class.
Custom Events: You can log custom events by using the TelemetryClient class.
Custom Properties: You can add custom properties to existing telemetry data by using the ITelemetryInitializer interface.

6. Best Practices for Using Application Insights

Enable Application Insights Early: Enable Application Insights as soon as possible in the development cycle to track the performance of the application throughout its lifecycle.
Monitor Continuously: Continuously monitor your application to detect and diagnose issues proactively.
Use Analytics: Leverage the powerful analytics capabilities of Application Insights to gain deeper insights into your application's performance.
Customize Telemetry: Write custom code to collect additional telemetry data that can help you better understand your application's behavior.
Secure Your Data: Ensure that you secure your telemetry data by implementing appropriate security measures.

7. Conclusion

ASP.NET Core Application Insights is a powerful tool that provides comprehensive monitoring and diagnostic capabilities for ASP.NET Core applications. By using Application Insights, developers can gain insights into the performance and health of their applications, diagnose and fix issues proactively, and improve the overall user experience. With its rich set of features and ease of integration, Application Insights is an essential tool for any ASP.NET Core developer.

Step-by-Step Guide: Setting Up ASP.NET Core Application Insights

Navigating the intricacies of integrating Azure Application Insights into your ASP.NET Core application might feel daunting at first. However, with a structured approach, you can seamlessly monitor and diagnose the performance and usage of your application. This step-by-step guide will walk you through the entire process, from setting up the application to observing the data flow.

Prerequisites

An Azure Account: Ensure you have an active Azure subscription to create Application Insights resources.
Visual Studio 2019 or Later: Download and install the Community, Professional, or Enterprise edition of Visual Studio for development.
.NET SDK: Make sure you have the .NET SDK installed. You can verify this by running dotnet --version in your command line interface.

Step 1: Create an ASP.NET Core Web Application

Launch Visual Studio and select "Create a new project" from the start window.
Choose the "ASP.NET Core Web App (Model-View-Controller)" template.
- Name your project (e.g., MyApp), and click "Create".
In the next window, ensure you select the version of .NET Core (e.g., .NET 6.0), select "Enable Docker Support" (optional), and click "Create".

Step 2: Create an Application Insights Resource in Azure

Navigate to the Azure portal and log in with your Azure subscription.
Click on "Create a resource" and search for "Application Insights".
Select "Application Insights" and click "Create".
Configure the new resource:
- Name: Provide a unique name for your Application Insights resource (e.g., MyApp-AppInsights).
- Resource Group: Select or create a new resource group.
- Region: Choose the region closest to your users.
Click "Review + create" and then "Create" to provision the resource.

Step 3: Configure Application Insights in Your ASP.NET Core Project

Back in Visual Studio, follow these steps:

Install Application Insights: Open NuGet Package Manager Console and run the following command:
```
Install-Package Microsoft.ApplicationInsights.AspNetCore
```

Configure Services and Middleware:

Open Program.cs (in .NET 6 and later).

Add Azure Application Insights to the services collection and use it as middleware:

using Microsoft.ApplicationInsights.Extensibility;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

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

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

Set Application Insights Connection String:
- In the Azure portal, navigate to your Application Insights resource and go to "Overview".
- Copy the "Instrumentation Key".
- Open appsettings.json in your project and add the following:
```
{
  "ApplicationInsights": {
    "InstrumentationKey": "YOUR_INSTRUMENTATION_KEY"
  }
}
```
- Alternatively, you can add the connection string to "Configuration" > "Application Settings" in the Azure portal.

Step 4: Set Route and Run the Application

Define a Route (Optional):

If you haven’t already, create a new route for testing. Modify HomeController.cs:

public class HomeController : Controller
{
    private readonly ILogger<HomeController> _logger;

    public HomeController(ILogger<HomeController> logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        _logger.LogInformation("Visited Index page");
        return View();
    }

    public IActionResult Privacy()
    {
        _logger.LogInformation("Visited Privacy page");
        return View();
    }

    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
    public IActionResult Error()
    {
        return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
    }

    public IActionResult TestRoute()
    {
        _logger.LogInformation("Visited TestRoute page");
        return View();
    }
}

Add a View for the New Route:
- Navigate to Views/Home and create a new view TestRoute.cshtml.
Run the Application:
- Press F5 or click "Start" in Visual Studio to run your application.
- Visit various routes, including the new TestRoute to generate some telemetry data.

Step 5: Monitor Data Flow in Application Insights

Navigate to Application Insights Portal:
- Go to the Azure portal and open your Application Insights resource.
Explore Different Telemetry Data:
- Overview: Check out the live metrics dashboard to see real-time data.
- Metrics: Explore pre-built charts and create custom metrics and metric charts.
- Failures: View and analyze exceptions and failed requests.
- Usage: Analyze user activity and application usage trends.
- Performance: Examine the performance of your application and identify slow endpoints.

Conclusion

By following the above steps, you have successfully integrated Azure Application Insights into your ASP.NET Core application. This integration allows you to monitor and diagnose the performance and usage of your app in real-time, providing deep insights to improve app quality and user experience. As you continue to develop and deploy your application, keep leveraging Application Insights to make informed decisions and optimize your application continually. Happy coding!