How to Use Azure Monitor for Performance Tracking with Alerts using C#

Introduction

Azure Monitor is an all-in-one solution for gathering, analyzing, and responding to telemetry data from both cloud and on-premises environments. With Azure Monitor, you gain insights into the performance of your applications, infrastructure, and network, allowing you to proactively address issues and maintain optimal performance. This article will guide you through using Azure Monitor for performance tracking and setting up alerts, featuring C# examples to illustrate key concepts.

Benefits of Using Azure Monitor for Performance Tracking

Azure Monitor is a powerful service for tracking, analyzing, and improving the performance of applications and infrastructure in Azure, on-premises, or hybrid environments. Here are the key benefits.

End-to-End Visibility
- Monitor applications, infrastructure, and networks in a single platform.
- Supports Azure resources, on-premises servers, and third-party cloud services.
Advanced Performance Insights
- Collects and analyzes logs, metrics, and telemetry data.
- Helps identify bottlenecks, slow response times, and failures.
Proactive Alerting & Automation
- Custom alerts notify teams when thresholds are breached.
- Automated actions (e.g., scaling resources, restarting services) reduce downtime.
Seamless Integration with Azure Services
- Works with Azure Security Center, Application Insights, and Log Analytics.
- Supports Power BI, Grafana, and third-party tools for reporting.
Application Performance Monitoring (APM) with Application Insights
- Tracks server response times, dependencies, and errors.
- Detects anomalies and suggests code-level improvements.
Real-Time & Historical Data Analysis
- View live metrics for quick troubleshooting.
- Analyze historical trends for capacity planning and optimization.
Cost Optimization
- Identifies underutilized resources to reduce costs.
- Helps optimize autoscaling strategies.
Security & Compliance Monitoring
- Detects suspicious activities and security threats.
- Ensures compliance with industry standards (ISO, HIPAA, etc.).

Setting Up Azure Monitor

Before using Azure Monitor, you need to set up monitoring for your resources.

Enable Diagnostic Settings: Configure the diagnostic settings for your Azure resources to send logs to Azure Monitor.
Create an Application Insights Instance: If you are monitoring an application, create an Application Insights resource in the Azure portal.
Configure Log Analytics: Log Analytics allows you to query and analyze logs from various sources.

Create an Azure Monitor Resource

Sign in to the Azure Portal.
In the left sidebar, select "Create a resource".
Search for "Monitor" and select the Azure Monitor service.
Follow the prompts to create a Monitor resource in your desired subscription and resource group.

Configure Application Insights

To track the performance of your application specifically, you can configure Application Insights.

In the Azure Portal, navigate to your Monitor resource.
Click on "Application Insights" and then "Add".
Fill in the necessary details to create a new Application Insights resource.

Integrating Azure Monitor with C#

To collect performance data, you need to instrument your application to send telemetry to Azure Monitor. To track performance using Azure Monitor in a C# application, you can use the Microsoft.ApplicationInsights SDK.

Step 1. Install the Required NuGet Packages.

Install-Package Microsoft.ApplicationInsights 
Install-Package Microsoft.Azure.Management.Monitor

Step 2. Configure Application Insights in C#.

Modify your appsettings.json or environment variables to include the Instrumentation Key for Application Insights.

{ 
  "ApplicationInsights": { 
    "InstrumentationKey": "your-instrumentation-key" 
  } 
}

Step 3. Initialize Application Insights.

In your Startup.cs (for ASP.NET Core) or your application entry point, add the following.

public class Program 
{ 
    private static TelemetryClient telemetryClient; 
     
    static void Main(string[] args) 
    { 
        var config = TelemetryConfiguration.CreateDefault(); 
        config.InstrumentationKey = "your-instrumentation-key"; 
        telemetryClient = new TelemetryClient(config); 
 
        TrackCustomMetrics(); 
    } 
 
    static void TrackCustomMetrics() 
    { 
        telemetryClient.TrackEvent("ApplicationStarted"); 
        telemetryClient.TrackMetric("CPU Usage", 75.0); 
        telemetryClient.TrackException(new Exception("Test Exception")); 
        telemetryClient.Flush(); 
    } 
}

Setting Up Alerts with Azure Monitor

To create alerts in Azure Monitor programmatically, use the Azure SDK for .NET.

Step 1. Install Required NuGet Packages.

Install-Package Microsoft.Azure.Management.Monitor.Fluent

Step 2. Authenticate and Create an Alert Rule.

using System; 
using Microsoft.Azure.Management.Monitor.Fluent; 
using Microsoft.Azure.Management.Fluent; 
using Microsoft.Azure.Management.ResourceManager.Fluent; 
 
class Program 
{ 
    static void Main(string[] args) 
    { 
        var credentials = SdkContext.AzureCredentialsFactory 
            .FromFile("path-to-auth-file.json"); 
 
        var azure = Microsoft.Azure.Management.Fluent.Azure 
            .Authenticate(credentials) 
            .WithDefaultSubscription(); 
 
        var resourceGroupName = "your-resource-group"; 
        var alertRuleName = "HighCPUAlert"; 
        var targetResourceId = "your-resource-id"; 
 
        var alert = azure.Alerts.Define(alertRuleName) 
            .WithExistingResourceGroup(resourceGroupName) 
            .WithTargetResource(targetResourceId) 
            .WithMetricName("Percentage CPU") 
            .WithCondition(MetricAlertRuleCondition.GreaterThan, 80) 
            .WithActionGroup("your-action-group-id") 
            .Create(); 
 
        Console.WriteLine("Alert rule created successfully."); 
    } 
}

Querying Metrics Using Azure Monitor

You can also fetch performance data using Log Analytics queries.

using System; 
using System.Threading.Tasks; 
using Azure.Identity; 
using Azure.Monitor.Query; 
using Azure.Monitor.Query.Models; 
 
class Program 
{ 
    static async Task Main(string[] args) 
    { 
        var client = new LogsQueryClient(new DefaultAzureCredential()); 
        string workspaceId = "your-workspace-id"; 
        string query = "Perf | where CounterName == 'CPU Usage' | take 10"; 
         
        Response<LogsQueryResult> response = await client.QueryWorkspaceAsync(workspaceId, query, QueryTimeRange.LastDay); 
         
        foreach (var table in response.Value.Tables) 
        { 
            foreach (var row in table.Rows) 
            { 
                Console.WriteLine(string.Join(", ", row)); 
            } 
        } 
    } 
}

Performance Monitoring Features

Request & Response Time Tracking: You can track how long API endpoints take to execute and detect slow responses.

var telemetryClient = new TelemetryClient(); 
var timer = Stopwatch.StartNew(); 
 
// Simulate request processing 
await Task.Delay(1000); 
 
timer.Stop(); 
telemetryClient.TrackMetric("API_Response_Time", timer.ElapsedMilliseconds);

Dependency Tracking (e.g., Database Queries): Monitor database performance and external service dependencies.

using (var telemetry = new DependencyTelemetry()) 
{ 
    telemetry.Name = "SQL Database Query"; 
    telemetry.Type = "SQL"; 
    telemetry.Data = "SELECT * FROM Orders"; 
    telemetry.Timestamp = DateTime.UtcNow; 
    telemetryClient.TrackDependency(telemetry); 
}

Exception Tracking: Capture and log exceptions automatically.

try 
{ 
    int x = 0; 
    int result = 10 / x; // Will throw a DivideByZeroException 
} 
catch (Exception ex) 
{ 
    telemetryClient.TrackException(ex); 
}

Importance of Using Azure Monitor in C# Applications

Feature	Benefit
Automatic Telemetry Collection	Logs performance data, requests, and exceptions without manual code changes.
Real-Time Insights	Detects slow responses, high resource usage, and failures immediately.
Centralized Logging with Log Analytics	Collects logs across multiple services for easier troubleshooting.
AI-Driven Alerts & Insights	Predicts performance issues before they impact users.
Cost Optimization	Identifies underutilized resources and optimizes autoscaling.

Best Practices for C# Performance Monitoring

Enable Application Insights early in the development cycle.
Use custom telemetry for tracking key business metrics.
Analyze logs using KQL for better insights.
Set up alerts for performance thresholds (e.g., high response times).
Integrate with Power BI or Grafana for better visualization.

When to Use (Use Cases)?

Monitor VM and Kubernetes performance
Track database query execution times
Analyze API response times
Monitor disk, CPU, and memory usage
Detect and troubleshoot application failures

Conclusion

Azure Monitor, combined with Application Insights, provides powerful capabilities for tracking the performance of your applications and ensuring a robust monitoring strategy. By following the steps outlined in this article, you can effectively set up Azure Monitor, instrument your C# application for telemetry, and configure alerts to keep your applications performing optimally. With proactive monitoring and alerting in place, you can minimize downtime and improve user experience.