A Step-by-Step Guide to Azure Insights Integration with .NET Core API

Welcome to the second part of our Microsoft Azure Insights Integration documentation series! This series will guide you through various aspects of integrating Azure Insights across different technologies and platforms. Below is an overview of the topics covered in this series:

1. Getting Started with Microsoft Azure Insights Integration

2. A Step-by-Step Guide to Azure Insights Integration with .NET Core API (You’re here!)

3. Streamlining Microsoft Azure Insights Integration with Angular

4. Log Request Payloads Using Custom Events in Microsoft Azure Insights

5. Tracking Response Exceptions via Custom Event Logging in Azure Insights

In this second part, we will walk through the detailed steps required to integrate Azure Insights with a .NET Core API.

This guide explains how to integrate Microsoft Azure Insights into a .NET Core API. By doing so, we can monitor, diagnose, and gather critical insights into the performance and usage of the application, helping to ensure smooth and efficient operation.

Prerequisites

• .NET Core Application: Backend API built using .NET Core (minimum version 3.1 or higher).

• Azure Subscription: Access to Microsoft Azure services.

• Azure Application Insights SDKs: For .NET.

• Basic knowledge of Application Insights: Familiarity with logging and telemetry.

Step 1: Set Up Application Insights in Azure

1. Create Application Insights Resource in Azure:

   • Log in to your Azure Portal.

   • Navigate to Application Insights and create a new resource.

   • Provide a name, select the appropriate subscription and resource group, and set your region (choose the region closest to your application's hosting).

   • Once the resource is created, go to the Overview page and copy the Instrumentation Key (this will be needed for both backend and frontend integration).

2. Configure Role-Based Access Control (RBAC):

   • Ensure that the appropriate permissions are granted for accessing the telemetry data. Add necessary users or service accounts with read or contributor access.

Step 2: Install Application Insights SDK for .NET Core

• Microsoft.ApplicationInsights.AspNetCore based on different versions of .NET:

• Use the following command in the terminal or in Visual Studio Package Manager Console:

  dotnet add package Microsoft.ApplicationInsights.AspNetCore

Step 3: Configure Application Insights in Startup.cs

Open the Startup.cs file and add the Application Insights service in the ConfigureServices method:

public void ConfigureServices(IServiceCollection services)
{
    var applicationInsightsEnabled = Configuration.GetValue<bool>("ApplicationInsights:TelemetryFeatureEnabled");
    if (applicationInsightsEnabled)
    {
        services.AddApplicationInsightsTelemetry(Configuration.GetSection("ApplicationInsights:ConnectionString"));
    }
}

Step 4: Adding New Configurations to appsettings.json

In your appsettings.json, add the Instrumentation Key and a feature flag to enable or disable the functionality:

{
  "Logging": {
    "ApplicationInsights": {
      "LogLevel": {
        "Default": "Information",
        "Microsoft": "Error",
        "System": "Information"
      }
    }
  },
  "ApplicationInsights": {
    "TelemetryFeatureEnabled": true,
    "ConnectionString": "YOUR_INSTRUMENTATION_KEY"
  }
}

This table provides a clear overview of the JSON configuration, explaining each setting and its purpose.

Step 5: Visualizing Application Insights in Azure

• The Overview section provides a quick, high-level view of key metrics, including:

  • Server Response Time

  • Failed Requests

  • Availability

  • CPU and Memory Usage

• Navigate to Metrics to create custom dashboards with a variety of visualizations. You can monitor metrics like:

  • Request Rate: Number of incoming requests.

  • Dependency Call Failures: Issues in external dependencies like databases or third-party APIs.

  • Exceptions: Application errors logged as exceptions.

  • Performance: Application latency and load times.

• Go to Investigate > Failures to get detailed insights into errors and exceptions occurring in your application:

  • Failed Requests: Examine requests that resulted in errors, including their status codes.

  • Dependency Failures: Track failed external calls (e.g., database, API).

  • Exception Logs: View detailed stack traces and error messages, helping you debug issues faster.

• Use Investigate > Performance to track how efficiently your application is running:

  • Response Times: Get detailed information about server response times for different endpoints.

  • Slow Requests: Identify which requests or transactions are taking longer than expected.

  • CPU and Memory Usage: Monitor resource utilization to detect performance bottlenecks.

• Navigate to Investigate > Availability to monitor the availability of your application or web service:

  • Availability Tests: Azure automatically pings your application from various locations to check its uptime.

  • Success Rate: Measure the percentage of successful availability tests.

  • Failure History: Drill down into failures with detailed logs and response times, along with geo-location insights.

• Under Investigate > Transaction Search, you can track individual transactions to understand the flow of requests and responses:

  • Search for Specific Requests: Use filters to find specific requests by URL, status code, or operation.

  • Trace Logs for Transactions: Drill down into the details of any request to see full traces of each step (e.g., database call, API call).

  • Custom Event Search: If you’re logging custom events, you can search and analyze them here for more granular tracking of application behaviors.

To view backend application insights data, please ensure that the Server toggle is selected instead of Browser. This will enable visibility of telemetry related to server-side activities such as API requests, exceptions, dependencies, and performance metrics.

Conclusion

In this guide, we've walked through the step-by-step process of integrating Microsoft Azure Insights with a .NET Core API. By following the outlined steps, you’ve set up telemetry to monitor your application's performance, exceptions, and dependencies in real time. This integration helps you gain valuable insights into your application's health, allowing for proactive issue resolution and enhanced performance monitoring. With Azure Insights in place, you can now track critical metrics that will empower you to make data-driven decisions for your .NET Core API’s ongoing development and optimization.