How to Monitor .NET Applications Using Azure Application Insights

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.