CM-1168: How to Measure The Application Performance in .NET Using IMeterFactory

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI/Controllers/MetricsController.cs

@@ -1,5 +1,6 @@
 using MetricsAPI.Services;
 using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics;
 
 namespace MetricsAPI.Controllers;
 
@@ -10,7 +11,7 @@ public class MetricsController(IMetricsService metricsService) : ControllerBase
     [HttpGet]
     public IActionResult Get()
     {
-        Random random = new();
+        var random = Random.Shared;
 
         metricsService.RecordUserClick();
 
@@ -21,11 +22,14 @@ public IActionResult Get()
 
         metricsService.RecordRequest();
 
-        metricsService.RecordMemoryConsumption(random.NextDouble() * 1000);
+        metricsService.RecordMemoryConsumption(GC.GetAllocatedBytesForCurrentThread() / (1024 * 1024));
 
         metricsService.RecordUserClickDetailed("US", "checkout");
 
-        metricsService.RecordResourceUsage(random.Next(1, 100), random.Next(16, 2048), random.Next(1, 16));
+        metricsService.RecordResourceUsage(
+            Utilities.GetCpuUsagePercentage(),
+            GC.GetTotalAllocatedBytes() / (1024 * 1024),
+            Process.GetCurrentProcess().Threads.Count);
 
         return Ok();
     }

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI/MetricsAPI.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI/Services/IMetricsService.cs

@@ -7,5 +7,5 @@ public interface IMetricsService
     void RecordRequest();
     void RecordMemoryConsumption(double value);
     void RecordUserClickDetailed(string region, string feature);
-    void RecordResourceUsage(int currentCpuUsage, int currentMemoryUsage, int currentThreadCount);
+    void RecordResourceUsage(double currentCpuUsage, double currentMemoryUsage, double currentThreadCount);
 }

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI/Services/MetricsService.cs

@@ -4,79 +4,78 @@ namespace MetricsAPI.Services;
 
 public class MetricsService : IMetricsService
 {
-    private readonly Counter<int> userClicks;
-    private readonly Histogram<double> responseTime;
+    private readonly Counter<int> _userClicks;
+    private readonly Histogram<double> _responseTime;
 
-    private int requests;
-    private double memoryConsumption;
-    private int cpu;
-    private int memory;
-    private int threadCount;
+    private int _requests;
+    private double _memoryConsumption;
+    private double _cpu;
+    private double _memory;
+    private double _threadCount;
 
     public MetricsService(IMeterFactory meterFactory)
     {
         Meter meter = meterFactory.Create("Metrics.Service");
 
-        userClicks = meter.CreateCounter<int>("metrics.service.user_clicks");
+        _userClicks = meter.CreateCounter<int>("metrics.service.user_clicks");
 
-        responseTime = meter.CreateHistogram<double>(name: "metrics.service.response_time",
+        _responseTime = meter.CreateHistogram<double>(name: "metrics.service.response_time",
             unit: "Seconds",
             description: "This metric measures the time taken for the application to respond to user requests.");
 
-        meter.CreateObservableCounter("metrics.service.requests", () => requests);
+        meter.CreateObservableCounter("metrics.service.requests", () => _requests);
 
-        meter.CreateObservableGauge(name: "metrics.service.memory_consumption",
-            () => memoryConsumption,
+        meter.CreateObservableGauge<double>(name: "metrics.service.memory_consumption",
+            () => _memoryConsumption,
             unit: "Megabytes",
             description: "This metric measures the amount of memory used by the application.");
 
-        meter.CreateObservableGauge(name: "metricsservice.resource_consumption",
+        meter.CreateObservableGauge(name: "metrics.service.resource_consumption",
             () => GetResourceConsumption());
     }
-
     public void RecordUserClick()
     {
-        userClicks.Add(1);
+        _userClicks.Add(1);
     }
 
     public void RecordResponseTime(double value)
     {
-        responseTime.Record(value);
+        _responseTime.Record(value);
     }
 
     public void RecordRequest()
     {
-        requests += 1;
+        Interlocked.Increment(ref _requests);
     }
 
     public void RecordMemoryConsumption(double value)
     {
-        memoryConsumption = value;
+        _memoryConsumption = value;
     }
 
     public void RecordUserClickDetailed(string region, string feature)
     {
-        userClicks.Add(1,
+        _userClicks.Add(1,
             new KeyValuePair<string, object?>("user.region", region),
             new KeyValuePair<string, object?>("user.feature", feature));
     }
 
-    public void RecordResourceUsage(int currentCpuUsage, int currentMemoryUsage, int currentThreadCount)
+    public void RecordResourceUsage(double currentCpuUsage, double currentMemoryUsage, double currentThreadCount)
     {
-        cpu = currentCpuUsage;
-        memory = currentMemoryUsage;
-        threadCount = currentThreadCount;
+        _cpu = currentCpuUsage;
+        _memory = currentMemoryUsage;
+        _threadCount = currentThreadCount;
     }
 
-    private IEnumerable<Measurement<int>> GetResourceConsumption()
+    private IEnumerable<Measurement<double>> GetResourceConsumption()
     {
         return
         [
-            new Measurement<int>(cpu, new KeyValuePair<string,object?>
+            new Measurement<double>(_cpu, new KeyValuePair<string,object?>
             ("resource_usage", "cpu")),
-            new Measurement<int>(memory, new KeyValuePair<string,object?>
+            new Measurement<double>(_memory, new KeyValuePair<string,object?>
             ("resource_usage", "memory")),
-            new Measurement<int>(threadCount, new KeyValuePair<string,object?>
+            new Measurement<double>(_threadCount, new KeyValuePair<string,object?>
             ("resource_usage", "thread_count")),
         ];
     }

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI/Services/Utilities.cs

@@ -0,0 +1,27 @@
+using System.Diagnostics;
+
+namespace MetricsAPI.Services
+{
+public static class Utilities
+{
+    public static double GetCpuUsagePercentage()
+    {
+        var process = Process.GetCurrentProcess();
+
+        var startTime = DateTime.UtcNow;
+        var initialCpuTime = process.TotalProcessorTime;
+
+        Thread.Sleep(1000);
+
+        var endTime = DateTime.UtcNow;
+        var finalCpuTime = process.TotalProcessorTime;
+
+        var totalCpuTimeUsed = (finalCpuTime - initialCpuTime).TotalMilliseconds;
+        var totalTimeElapsed = (endTime - startTime).TotalMilliseconds;
+
+        var cpuUsage = (totalCpuTimeUsed / (Environment.ProcessorCount * totalTimeElapsed)) * 100;
+
+        return cpuUsage;
+    }
+}
+}

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/Tests/MetricsTests.cs

@@ -11,7 +11,7 @@ public class MetricsTests
     public void GivenMetricsConfigured_WhenUserClickRecorded_ThenCounterCaptured()
     {
         // Arrange
-        var services = CreateServiceProvider();
+        using var services = CreateServiceProvider();
         var metrics = services.GetRequiredService<MetricsService>();
         var meterFactory = services.GetRequiredService<IMeterFactory>();
         var collector = new MetricCollector<int>(meterFactory, "Metrics.Service", "metrics.service.user_clicks");
@@ -29,7 +29,7 @@ public void GivenMetricsConfigured_WhenUserClickRecorded_ThenCounterCaptured()
     public void GivenMetricsConfigured_WhenRequestRecorded_ThenObservableCounterCaptured()
     {
         // Arrange
-        var services = CreateServiceProvider();
+        using var services = CreateServiceProvider();
         var metrics = services.GetRequiredService<MetricsService>();
         var meterFactory = services.GetRequiredService<IMeterFactory>();
         var collector = new MetricCollector<int>(meterFactory, "Metrics.Service", "metrics.service.requests");
@@ -44,11 +44,12 @@ public void GivenMetricsConfigured_WhenRequestRecorded_ThenObservableCounterCapt
         Assert.Equal(1, measurements[0].Value);
     }
 
-    private static IServiceProvider CreateServiceProvider()
+    private static ServiceProvider CreateServiceProvider()
     {
         var serviceCollection = new ServiceCollection();
         serviceCollection.AddMetrics();
         serviceCollection.AddSingleton<MetricsService>();
+
         return serviceCollection.BuildServiceProvider();
     }
 }

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/Tests/Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>