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

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI.sln

@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.12.35521.163
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MetricsAPI", "MetricsAPI\MetricsAPI.csproj", "{D81FB454-FDD5-439A-A996-D309484BECBF}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests", "Tests\Tests.csproj", "{EA4AF403-AE9B-4064-ABB9-69868DE6D34D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{D81FB454-FDD5-439A-A996-D309484BECBF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D81FB454-FDD5-439A-A996-D309484BECBF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D81FB454-FDD5-439A-A996-D309484BECBF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D81FB454-FDD5-439A-A996-D309484BECBF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EA4AF403-AE9B-4064-ABB9-69868DE6D34D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EA4AF403-AE9B-4064-ABB9-69868DE6D34D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EA4AF403-AE9B-4064-ABB9-69868DE6D34D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EA4AF403-AE9B-4064-ABB9-69868DE6D34D}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

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

@@ -0,0 +1,36 @@
+using MetricsAPI.Services;
+using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics;
+
+namespace MetricsAPI.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class MetricsController(IMetricsService metricsService) : ControllerBase
+{
+    [HttpGet]
+    public IActionResult Get()
+    {
+        var random = Random.Shared;
+
+        metricsService.RecordUserClick();
+
+        for (int i = 0; i < 100; i++)
+        {
+            metricsService.RecordResponseTime(random.NextDouble());
+        }
+
+        metricsService.RecordRequest();
+
+        metricsService.RecordMemoryConsumption(GC.GetAllocatedBytesForCurrentThread() / (1024 * 1024));
+
+        metricsService.RecordUserClickDetailed("US", "checkout");
+
+        metricsService.RecordResourceUsage(
+            Utilities.GetCpuUsagePercentage(),
+            GC.GetTotalAllocatedBytes() / (1024 * 1024),
+            Process.GetCurrentProcess().Threads.Count);
+
+        return Ok();
+    }
+}

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI/MetricsAPI.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="7.2.0" />
+  </ItemGroup>
+
+</Project>

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI/Program.cs

@@ -0,0 +1,20 @@
+using MetricsAPI.Services;
+
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddControllers();
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+builder.Services.AddSingleton<IMetricsService, MetricsService>();
+
+var app = builder.Build();
+
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+app.UseAuthorization();
+app.MapControllers();
+app.Run();

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI/Properties/launchSettings.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7052;http://localhost:5095",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,11 @@
+namespace MetricsAPI.Services;
+
+public interface IMetricsService
+{
+    void RecordUserClick();
+    void RecordResponseTime(double value);
+    void RecordRequest();
+    void RecordMemoryConsumption(double value);
+    void RecordUserClickDetailed(string region, string feature);
+    void RecordResourceUsage(double currentCpuUsage, double currentMemoryUsage, double currentThreadCount);
+}

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

@@ -0,0 +1,82 @@
+using System.Diagnostics.Metrics;
+
+namespace MetricsAPI.Services;
+
+public class MetricsService : IMetricsService
+{
+    private readonly Counter<int> _userClicks;
+    private readonly Histogram<double> _responseTime;
+
+    private int _requests;
+    private double _memoryConsumption;
+    private double _cpu;
+    private double _memory;
+    private double _threadCount;
+
+    public MetricsService(IMeterFactory meterFactory)
+    {
+        var meter = meterFactory.Create("Metrics.Service");
+
+        _userClicks = meter.CreateCounter<int>("metrics.service.user_clicks");
+
+        _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.CreateObservableGauge(name: "metrics.service.memory_consumption",
+            () => _memoryConsumption,
+            unit: "Megabytes",
+            description: "This metric measures the amount of memory used by the application.");
+
+        meter.CreateObservableGauge(name: "metrics.service.resource_consumption",
+            GetResourceConsumption);
+    }
+    public void RecordUserClick()
+    {
+        _userClicks.Add(1);
+    }
+
+    public void RecordResponseTime(double value)
+    {
+        _responseTime.Record(value);
+    }
+
+    public void RecordRequest()
+    {
+        Interlocked.Increment(ref _requests);
+    }
+
+    public void RecordMemoryConsumption(double value)
+    {
+        _memoryConsumption = value;
+    }
+
+    public void RecordUserClickDetailed(string region, string feature)
+    {
+        _userClicks.Add(1,
+            new KeyValuePair<string, object?>("user.region", region),
+            new KeyValuePair<string, object?>("user.feature", feature));
+    }
+
+    public void RecordResourceUsage(double currentCpuUsage, double currentMemoryUsage, double currentThreadCount)
+    {
+        _cpu = currentCpuUsage;
+        _memory = currentMemoryUsage;
+        _threadCount = currentThreadCount;
+    }
+
+    private IEnumerable<Measurement<double>> GetResourceConsumption()
+    {
+        return
+        [
+            new Measurement<double>(_cpu, new KeyValuePair<string,object?>
+            ("resource_usage", "cpu")),
+            new Measurement<double>(_memory, new KeyValuePair<string,object?>
+            ("resource_usage", "memory")),
+            new Measurement<double>(_threadCount, new KeyValuePair<string,object?>
+            ("resource_usage", "thread_count")),
+        ];
+    }
+}

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

@@ -0,0 +1,26 @@
+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/MetricsAPI/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/MetricsAPI/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/Tests/MetricsTests.cs

@@ -0,0 +1,55 @@
+using Microsoft.Extensions.DependencyInjection;
+using System.Diagnostics.Metrics;
+using Microsoft.Extensions.Diagnostics.Metrics.Testing;
+using MetricsAPI.Services;
+
+namespace Tests;
+
+public class MetricsTests
+{
+    [Fact]
+    public void GivenMetricsConfigured_WhenUserClickRecorded_ThenCounterCaptured()
+    {
+        // Arrange
+        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");
+
+        // Act
+        metrics.RecordUserClick();
+
+        // Assert
+        var measurements = collector.GetMeasurementSnapshot();
+        Assert.Single(measurements);
+        Assert.Equal(1, measurements[0].Value);
+    }
+
+    [Fact]
+    public void GivenMetricsConfigured_WhenRequestRecorded_ThenObservableCounterCaptured()
+    {
+        // Arrange
+        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");
+
+        // Act
+        metrics.RecordRequest();
+
+        // Assert
+        collector.RecordObservableInstruments();
+        var measurements = collector.GetMeasurementSnapshot();
+        Assert.Single(measurements);
+        Assert.Equal(1, measurements[0].Value);
+    }
+
+    private static ServiceProvider CreateServiceProvider()
+    {
+        var serviceCollection = new ServiceCollection();
+        serviceCollection.AddMetrics();
+        serviceCollection.AddSingleton<MetricsService>();
+
+        return serviceCollection.BuildServiceProvider();
+    }
+}

aspnetcore-features/PerformanceMonitoringWithIMeterFactory/Tests/Tests.csproj

@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.3">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics.Testing" Version="9.1.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MetricsAPI\MetricsAPI.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>