Добавил метод для получения нагрузки на процессор

Backend/MonitorAgent/MonitorAgent.Application/MonitorAgent.Application.csproj

@@ -4,6 +4,10 @@
     <ProjectReference Include="..\MonitorAgent.Core\MonitorAgent.Core.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.0" />
+  </ItemGroup>
+
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>

Backend/MonitorAgent/MonitorAgent.Application/Services/CpuMonitorBackgroundService.cs

@@ -0,0 +1,64 @@
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using MonitorAgent.Application.Settings;
+using MonitorAgent.Core.Models;
+
+namespace MonitorAgent.Application.Services;
+
+public class CpuMonitorBackgroundService(
+    RawCpuMonitorService cpuMonitorService,
+    IOptions<CpuMonitorSettings> options,
+    ILogger<CpuMonitorBackgroundService> logger) : BackgroundService
+{
+    private RawCpuStatsCollection? _prevStats;
+    private RawCpuStatsCollection? _nextStats;
+
+    public async Task<CpuUsage> GetCpuUsageAsync(CancellationToken cancellationToken = default)
+    {
+        RawCpuStatsCollection prev, next;
+        if (_prevStats != null)
+            prev = _prevStats;
+        else
+            prev = await cpuMonitorService.ParseRawCpuStatsAsync(cancellationToken);
+        if (_nextStats != null)
+            next = _nextStats;
+        else
+            next = await cpuMonitorService.ParseRawCpuStatsAsync(cancellationToken);
+
+        var total = CalcUsage(prev.Total, next.Total);
+        var cores = new List<decimal>(prev.Cores.Count);
+        for (int i = 0; i < prev.Cores.Count; i++)
+            cores.Add(CalcUsage(prev.Cores[i], next.Cores[i]));
+
+        return new CpuUsage(total, cores);
+    }
+    
+    private decimal CalcUsage(RawCpuStats prev, RawCpuStats next)
+    {
+        decimal deltaTotal = next.Total - prev.Total;
+        decimal deltaIdle = next.Idle - prev.Idle;
+
+        return (1 - deltaIdle / deltaTotal) * 100;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                _prevStats = _nextStats;
+                _nextStats = await cpuMonitorService.ParseRawCpuStatsAsync(stoppingToken);
+            }
+            catch (Exception e)
+            {
+                logger.LogError(e.Message);
+            }
+            finally
+            {
+                await Task.Delay(options.Value.DelayTime, stoppingToken);
+            }
+        }
+    }
+}

Backend/MonitorAgent/MonitorAgent.Application/Services/RawCpuMonitorService.cs

@@ -0,0 +1,19 @@
+using MonitorAgent.Core.Abstraction;
+using MonitorAgent.Core.Models;
+
+namespace MonitorAgent.Application.Services;
+
+public class RawCpuMonitorService : ICpuMonitorService
+{
+    public async Task<RawCpuStatsCollection> ParseRawCpuStatsAsync(CancellationToken cancellationToken = default)
+    {
+        var raw = await File.ReadAllLinesAsync("/proc/stat", cancellationToken);
+        
+        var total = RawCpuStats.Parse(raw[0]);
+        var cores = new List<RawCpuStats>();
+        for (int i = 1; i < raw.Length && raw[i].StartsWith("cpu"); i++)
+            cores.Add(RawCpuStats.Parse(raw[i]));
+
+        return new RawCpuStatsCollection(total, cores);
+    }
+}

Backend/MonitorAgent/MonitorAgent.Application/Settings/CpuMonitorSettings.cs

@@ -0,0 +1,6 @@
+namespace MonitorAgent.Application.Settings;
+
+public class CpuMonitorSettings
+{
+    public int DelayTime { get; set; } = 1000;
+}