.NET  

How to Monitor .NET Applications Using Azure Application Insights

Introduction: Why Flying Blind is a Bad Idea

Imagine driving a car down a busy highway with your dashboard completely taped over. You don't know your speed, you have no idea if you are running out of gas, and the check engine light could be flashing without you ever knowing.

Running a web application without a proper monitoring tool is exactly the same. Whether you are a .NET developer building APIs in Bangalore, scaling enterprise software in London, or managing cloud services in Seattle, you need to know exactly how your application is behaving in the real world. Are users experiencing slow loading times? Is your database randomly throwing errors at 2:00 AM?

This is where Azure Application Insights comes to the rescue. It is like the ultimate, high-tech dashboard for your .NET applications. In this article, we will walk through exactly what Azure Application Insights is and how you can implement it in your .NET application step-by-step.

What is Azure Application Insights?

Azure Application Insights is a feature of Azure Monitor. It is an extensible Application Performance Management (APM) service built for developers. In simple terms, it acts as a smart detective that sits inside your application, silently taking notes on everything that happens.

It automatically detects performance anomalies and includes powerful analytics tools to help you diagnose issues and understand what users actually do with your app.

Here is what it tracks automatically out of the box:

  • Request Rates and Response Times: How many people are using your app and how fast your app is responding.

  • Dependency Rates: How fast your app talks to databases, external APIs, and other cloud services.

  • Exceptions and Errors: Detailed stack traces of any code crashes.

  • Page Views and User Behavior: If you have a front-end, it tracks what pages users visit.

Step-by-Step Guide to Implementing Application Insights in .NET

Let’s get our hands dirty. We are going to connect a modern .NET Core (or .NET 6/7/8) Web API or MVC application to Azure Application Insights.

Step 1: Create an Application Insights Resource in Azure

Before we touch any code, we need a place in the cloud to send our data.

  1. Log in to your Azure Portal.

  2. In the search bar at the top, type Application Insights and select it.

  3. Click the Create button.

  4. Fill in the basic details:

    • Subscription: Choose your Azure subscription.

    • Resource Group: Create a new one or select an existing one.

    • Name: Give it a clear name (e.g., MyApp-AppInsights-Prod).

    • Region: Pick the region closest to your users or where your app is hosted.

  5. Click Review + Create, then Create.

  6. Once the resource is ready, go to its Overview page. Look for the Connection String and copy it. You will need this in Step 3!

Step 2: Install the NuGet Package in Your .NET App

Now, open your .NET project in Visual Studio, Rider, or VS Code. We need to install the SDK that allows our app to talk to Azure.

Open your NuGet Package Manager or the Package Manager Console and run this command:

PowerShell

Install-Package Microsoft.ApplicationInsights.AspNetCore

(Note: If you are using the .NET CLI, the command is dotnet add package Microsoft.ApplicationInsights.AspNetCore)

Step 3: Configure the Connection String

Your app needs to know where to send its detective notes. We do this by adding the Connection String we copied in Step 1 to our configuration file.

Open your appsettings.json file and add a new section for Application Insights:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ApplicationInsights": {
    "ConnectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://your-region.in.applicationinsights.azure.com/;"
  }
}

(Make sure to paste your actual Connection String, not the dummy one above!)

Step 4: Register the Service in Program.cs

With the package installed and the connection string ready, we just need to tell ASP.NET Core to turn the service on.

Open your Program.cs file. Add this single line of code right under where you add your other services:

var builder = WebApplication.CreateBuilder(args);

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

// Add Application Insights Telemetry!
builder.Services.AddApplicationInsightsTelemetry();

var app = builder.Build();

That’s it! With just these few steps, your application is now fully monitored. If you run your app and click around, it will automatically start sending request logs, dependency tracking, and error reports to Azure.

Step 5: Going Beyond the Basics (Custom Telemetry)

Automatic tracking is great, but sometimes you want to track specific business events. For example, "How many users completed a checkout?" or "What was the total value of the shopping cart?"

You can easily do this by injecting the TelemetryClient into your controllers or services.

Here is an example of tracking a custom event when a user places an order:

using Microsoft.AspNetCore.Mvc;
using Microsoft.ApplicationInsights;

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly TelemetryClient _telemetryClient;

    // Inject the TelemetryClient
    public OrdersController(TelemetryClient telemetryClient)
    {
        _telemetryClient = telemetryClient;
    }

    [HttpPost("checkout")]
    public IActionResult Checkout(Order order)
    {
        // Process the order logic here...

        // Track a custom event
        var properties = new Dictionary<string, string> { { "ItemCategory", order.Category } };
        var metrics = new Dictionary<string, double> { { "OrderTotal", order.TotalAmount } };
        
        _telemetryClient.TrackEvent("OrderCompleted", properties, metrics);

        return Ok("Order processed!");
    }
}

Now, in your Azure portal, you can search for the OrderCompleted event and see exactly how your business is performing, not just how your code is performing!

Step 6: Viewing the Magic in the Azure Portal

Once your app has been running for a few minutes, head back to the Application Insights resource in the Azure Portal. Here are the coolest features you should check out:

  1. Application Map: This is a visual map of your entire system. It shows your .NET app as a circle, with lines pointing to your databases, external APIs, and storage accounts. If your database is slow, the line connecting them will turn red, showing you the exact bottleneck!

  2. Live Metrics: Click on "Live Metrics" on the left menu. You will see real-time, second-by-second graphs of CPU usage, incoming requests, and failure rates. It is incredibly satisfying to watch when you deploy a new feature.

  3. Failures: This tab categorizes every exception thrown by your app. You can click on a specific error, and Azure will show you the exact line of code that failed and the user request that triggered it.

Conclusion

Monitoring is not a luxury; it is an absolute necessity for modern software development. By integrating Azure Application Insights into your .NET application, you transform from guessing what went wrong to knowing exactly where, when, and why an issue occurred. It saves hours of debugging and ensures your users get the fast, reliable experience they expect.

Membership not found