Add metrics with correct names for Resource Monitoring

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Calculator.cs

@@ -25,7 +25,7 @@ public static ResourceUtilization CalculateUtilization(in Snapshot first, in Sna
         long runtimeTickDelta = second.TotalTimeSinceStart.Ticks - first.TotalTimeSinceStart.Ticks;
 
         // Compute the total number of ticks available on the machine during that interval
-        double totalSystemTicks = runtimeTickDelta * systemResources.GuaranteedCpuUnits;
+        double totalSystemTicks = runtimeTickDelta;
 
         // fudge to avoid divide by zero
         if (totalSystemTicks <= 0)

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Linux/LinuxUtilizationParserCgroupV1.cs

@@ -444,7 +444,7 @@ private static bool TryGetCpuUnitsFromCgroups(IFileSystem fileSystem, out float
     /// <summary>
     /// In cgroup v1 the CPU shares is used to determine the CPU allocation.
     /// in cgroup v2 the CPU weight is used to determine the CPU allocation.
-    /// To calculete CPU request in cgroup v2 we need to read the CPU weight and convert it to CPU shares.
+    /// To calculate CPU request in cgroup v2 we need to read the CPU weight and convert it to CPU shares.
     /// But for cgroup v1 we can read the CPU shares directly from the file.
     /// 1024 equals 1 CPU core.
     /// In cgroup v1 on some systems the location of the CPU shares file is different.

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Linux/LinuxUtilizationProvider.cs

@@ -15,12 +15,13 @@ internal sealed class LinuxUtilizationProvider : ISnapshotProvider
     private readonly object _cpuLocker = new();
     private readonly object _memoryLocker = new();
     private readonly ILinuxUtilizationParser _parser;
-    private readonly ulong _totalMemoryInBytes;
+    private readonly ulong _memoryLimit;
     private readonly TimeSpan _cpuRefreshInterval;
     private readonly TimeSpan _memoryRefreshInterval;
     private readonly TimeProvider _timeProvider;
-    private readonly double _scale;
-    private readonly double _scaleForTrackerApi;
+    private readonly double _scaleRelativeToCpuLimit;
+    private readonly double _scaleRelativeToCpuRequest;
+    private readonly double _scaleRelativeToCpuRequestForTrackerApi;
 
     private DateTimeOffset _refreshAfterCpu;
     private DateTimeOffset _refreshAfterMemory;
@@ -42,68 +43,74 @@ public LinuxUtilizationProvider(IOptions<ResourceMonitoringOptions> options, ILi
         _memoryRefreshInterval = options.Value.MemoryConsumptionRefreshInterval;
         _refreshAfterCpu = now;
         _refreshAfterMemory = now;
-        _totalMemoryInBytes = _parser.GetAvailableMemoryInBytes();
+        _memoryLimit = _parser.GetAvailableMemoryInBytes();
         _previousHostCpuTime = _parser.GetHostCpuUsageInNanoseconds();
         _previousCgroupCpuTime = _parser.GetCgroupCpuUsageInNanoseconds();
 
-        var hostMemory = _parser.GetHostAvailableMemory();
         var hostCpus = _parser.GetHostCpuCount();
-        var availableCpus = _parser.GetCgroupLimitedCpus();
-        var cpuGuaranteedRequest = _parser.GetCgroupRequestCpu();
-        _scale = hostCpus / availableCpus;
-        _scaleForTrackerApi = hostCpus / availableCpus;
+        var cpuLimit = _parser.GetCgroupLimitedCpus();
+        var cpuRequest = _parser.GetCgroupRequestCpu();
+        _scaleRelativeToCpuLimit = hostCpus / cpuLimit;
+        _scaleRelativeToCpuRequest = hostCpus / cpuRequest;
+        _scaleRelativeToCpuRequestForTrackerApi = hostCpus; // the division by cpuRequest is performed later on in the ResourceUtilization class
 
 #pragma warning disable CA2000 // Dispose objects before losing scope
         // We don't dispose the meter because IMeterFactory handles that
         // An issue on analyzer side: https://github.com/dotnet/roslyn-analyzers/issues/6912
         // Related documentation: https://github.com/dotnet/docs/pull/37170
-        var meter = meterFactory.Create("Microsoft.Extensions.Diagnostics.ResourceMonitoring");
+        var meter = meterFactory.Create(nameof(Microsoft.Extensions.Diagnostics.ResourceMonitoring));
 #pragma warning restore CA2000 // Dispose objects before losing scope
 
-        _ = meter.CreateObservableGauge(name: ResourceUtilizationInstruments.CpuUtilization, observeValue: CpuUtilization, unit: "1");
-        _ = meter.CreateObservableGauge(name: ResourceUtilizationInstruments.MemoryUtilization, observeValue: MemoryUtilization, unit: "1");
+        if (options.Value.UseContainerMetricNames)
+        {
+            _ = meter.CreateObservableGauge(name: ResourceUtilizationInstruments.ContainerCpuLimitUtilization, observeValue: () => CpuUtilization() * _scaleRelativeToCpuLimit, unit: "1");
+            _ = meter.CreateObservableGauge(name: ResourceUtilizationInstruments.ContainerMemoryLimitUtilization, observeValue: MemoryUtilization, unit: "1");
+            _ = meter.CreateObservableGauge(name: ResourceUtilizationInstruments.ContainerCpuRequestUtilization, observeValue: () => CpuUtilization() * _scaleRelativeToCpuRequest, unit: "1");
+        }
+        else
+        {
+            // Old metrics, obsolete for this class, but used by WindowsSnapshotProvider. Keeping them for backward compatibility:
+            _ = meter.CreateObservableGauge(name: ResourceUtilizationInstruments.ProcessCpuUtilization, observeValue: () => CpuUtilization() * _scaleRelativeToCpuRequest, unit: "1");
+            _ = meter.CreateObservableGauge(name: ResourceUtilizationInstruments.ProcessMemoryUtilization, observeValue: MemoryUtilization, unit: "1");
+        }
 
-        // cpuGuaranteedRequest is a CPU request for pod, for host its 1 core
-        // available CPUs is a CPU limit for a pod or for a host.
-        // _totalMemoryInBytes - Resource Memory Limit (in k8s terms)
-        // _totalMemoryInBytes - To keep the contract, this parameter will get the Host available memory
-        Resources = new SystemResources(cpuGuaranteedRequest, availableCpus, _totalMemoryInBytes, _totalMemoryInBytes);
+        // cpuRequest is a CPU request (aka guaranteed number of CPU units) for pod, for host its 1 core
+        // cpuLimit is a CPU limit (aka max CPU units available) for a pod or for a host.
+        // _memoryLimit - Resource Memory Limit (in k8s terms)
+        // _memoryLimit - To keep the contract, this parameter will get the Host available memory
+        Resources = new SystemResources(cpuRequest, cpuLimit, _memoryLimit, _memoryLimit);
     }
 
     public double CpuUtilization()
     {
         var now = _timeProvider.GetUtcNow();
-        bool needUpdate = false;
 
         lock (_cpuLocker)
         {
-            if (now >= _refreshAfterCpu)
+            if (now < _refreshAfterCpu)
             {
-                needUpdate = true;
+                return _cpuPercentage;
             }
         }
 
-        if (needUpdate)
-        {
-            var hostCpuTime = _parser.GetHostCpuUsageInNanoseconds();
-            var cgroupCpuTime = _parser.GetCgroupCpuUsageInNanoseconds();
+        var hostCpuTime = _parser.GetHostCpuUsageInNanoseconds();
+        var cgroupCpuTime = _parser.GetCgroupCpuUsageInNanoseconds();
 
-            lock (_cpuLocker)
+        lock (_cpuLocker)
+        {
+            if (now >= _refreshAfterCpu)
             {
-                if (now >= _refreshAfterCpu)
+                var deltaHost = hostCpuTime - _previousHostCpuTime;
+                var deltaCgroup = cgroupCpuTime - _previousCgroupCpuTime;
+
+                if (deltaHost > 0 && deltaCgroup > 0)
                 {
-                    var deltaHost = hostCpuTime - _previousHostCpuTime;
-                    var deltaCgroup = cgroupCpuTime - _previousCgroupCpuTime;
-
-                    if (deltaHost > 0 && deltaCgroup > 0)
-                    {
-                        var percentage = Math.Min(One, deltaCgroup / deltaHost * _scale);
-
-                        _cpuPercentage = percentage;
-                        _refreshAfterCpu = now.Add(_cpuRefreshInterval);
-                        _previousCgroupCpuTime = cgroupCpuTime;
-                        _previousHostCpuTime = hostCpuTime;
-                    }
+                    var percentage = Math.Min(One, deltaCgroup / deltaHost);
+
+                    _cpuPercentage = percentage;
+                    _refreshAfterCpu = now.Add(_cpuRefreshInterval);
+                    _previousCgroupCpuTime = cgroupCpuTime;
+                    _previousHostCpuTime = hostCpuTime;
                 }
             }
         }
@@ -114,29 +121,25 @@ public double CpuUtilization()
     public double MemoryUtilization()
     {
         var now = _timeProvider.GetUtcNow();
-        bool needUpdate = false;
 
         lock (_memoryLocker)
         {
-            if (now >= _refreshAfterMemory)
+            if (now < _refreshAfterMemory)
             {
-                needUpdate = true;
+                return _memoryPercentage;
             }
         }
 
-        if (needUpdate)
-        {
-            var memoryUsed = _parser.GetMemoryUsageInBytes();
+        var memoryUsed = _parser.GetMemoryUsageInBytes();
 
-            lock (_memoryLocker)
+        lock (_memoryLocker)
+        {
+            if (now >= _refreshAfterMemory)
             {
-                if (now >= _refreshAfterMemory)
-                {
-                    var memoryPercentage = Math.Min(One, (double)memoryUsed / _totalMemoryInBytes);
+                var memoryPercentage = Math.Min(One, (double)memoryUsed / _memoryLimit);
 
-                    _memoryPercentage = memoryPercentage;
-                    _refreshAfterMemory = now.Add(_memoryRefreshInterval);
-                }
+                _memoryPercentage = memoryPercentage;
+                _refreshAfterMemory = now.Add(_memoryRefreshInterval);
             }
         }
 
@@ -157,7 +160,7 @@ public Snapshot GetSnapshot()
         return new Snapshot(
             totalTimeSinceStart: TimeSpan.FromTicks(hostTime / Hundred),
             kernelTimeSinceStart: TimeSpan.Zero,
-            userTimeSinceStart: TimeSpan.FromTicks((long)(cgroupTime / Hundred * _scaleForTrackerApi)),
+            userTimeSinceStart: TimeSpan.FromTicks((long)(cgroupTime / Hundred * _scaleRelativeToCpuRequestForTrackerApi)),
             memoryUsageInBytes: memoryUsed);
     }
 }

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/ResourceMonitoringOptions.cs

@@ -2,7 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Shared.Data.Validation;
+using Microsoft.Shared.DiagnosticIds;
 
 namespace Microsoft.Extensions.Diagnostics.ResourceMonitoring;
 
@@ -54,4 +56,13 @@ public partial class ResourceMonitoringOptions
     /// </remarks>
     [TimeSpan(MinimumSamplingWindow, MaximumSamplingWindow)]
     public TimeSpan PublishingWindow { get; set; } = DefaultCollectionWindow;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to use container metric names "container.*" instead of process metric names "process.*.".
+    /// </summary>
+    /// <remarks>
+    /// Container metric names is the way forward and will be the default in the future.
+    /// </remarks>
+    [Experimental(DiagnosticIds.Experiments.ResourceMonitoring, UrlFormat = DiagnosticIds.UrlFormat)]
+    public bool UseContainerMetricNames { get; set; }
 }

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/ResourceMonitoringServiceCollectionExtensions.cs

@@ -88,7 +88,7 @@ private static ResourceMonitorBuilder AddWindowsProvider(this ResourceMonitorBui
         builder.PickWindowsSnapshotProvider();
 
         _ = builder.Services
-            .AddActivatedSingleton<WindowsCounters>();
+            .AddActivatedSingleton<WindowsNetworkMetrics>();
 
         _ = builder.Services
             .AddActivatedSingleton<TcpTableInfo>();

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/ResourceUtilization.cs

@@ -51,10 +51,16 @@ public readonly struct ResourceUtilization
     /// <param name="systemResources">CPU and memory limits.</param>
     public ResourceUtilization(double cpuUsedPercentage, ulong memoryUsedInBytes, SystemResources systemResources)
     {
-        CpuUsedPercentage = Throw.IfLessThan(cpuUsedPercentage, 0.0);
+        var guaranteedCpuUnits = systemResources.GuaranteedCpuUnits;
+        if (guaranteedCpuUnits <= 0)
+        {
+            guaranteedCpuUnits = 1;
+        }
+
+        CpuUsedPercentage = Throw.IfLessThan(cpuUsedPercentage / guaranteedCpuUnits, 0.0);
         MemoryUsedInBytes = Throw.IfLessThan(memoryUsedInBytes, 0);
         SystemResources = systemResources;
-        MemoryUsedPercentage = Math.Min(Hundred, (double)MemoryUsedInBytes / SystemResources.GuaranteedMemoryInBytes * Hundred);
+        MemoryUsedPercentage = Math.Min(Hundred, (double)MemoryUsedInBytes / systemResources.GuaranteedMemoryInBytes * Hundred);
     }
 
     /// <summary>

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/ResourceUtilizationInstruments.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
+
 namespace Microsoft.Extensions.Diagnostics.ResourceMonitoring;
 
 /// <summary>
@@ -13,18 +15,42 @@ namespace Microsoft.Extensions.Diagnostics.ResourceMonitoring;
 internal static class ResourceUtilizationInstruments
 {
     /// <summary>
-    /// Gets the CPU consumption of the running application in range <c>[0, 1]</c>.
+    /// Gets the CPU consumption share of the running process in range <c>[0, 1]</c>.
+    /// </summary>
+    /// <remarks>
+    /// The type of an instrument is <see cref="System.Diagnostics.Metrics.ObservableGauge{T}"/>.
+    /// </remarks>
+    public const string ProcessCpuUtilization = "process.cpu.utilization";
+
+    /// <summary>
+    /// Gets the memory consumption share of the running process in range <c>[0, 1]</c>.
+    /// </summary>
+    /// <remarks>
+    /// The type of an instrument is <see cref="System.Diagnostics.Metrics.ObservableGauge{T}"/>.
+    /// </remarks>
+    public const string ProcessMemoryUtilization = "dotnet.process.memory.virtual.utilization";
+
+    /// <summary>
+    /// Gets the CPU limit consumption of all processes running inside a container or control group in range <c>[0, 1]</c>.
+    /// </summary>
+    /// <remarks>
+    /// The type of an instrument is <see cref="System.Diagnostics.Metrics.ObservableGauge{T}"/>.
+    /// </remarks>
+    public const string ContainerCpuLimitUtilization = "container.cpu.limit.utilization";
+
+    /// <summary>
+    /// Gets the CPU request consumption of all processes running inside a container or control group in range <c>[0, 1]</c>.
     /// </summary>
     /// <remarks>
     /// The type of an instrument is <see cref="System.Diagnostics.Metrics.ObservableGauge{T}"/>.
     /// </remarks>
-    public const string CpuUtilization = "process.cpu.utilization";
+    public const string ContainerCpuRequestUtilization = "container.cpu.request.utilization";
 
     /// <summary>
-    /// Gets the memory consumption of the running application in range <c>[0, 1]</c>.
+    /// Gets the memory limit consumption of all processes running inside a container or control group in range <c>[0, 1]</c>.
     /// </summary>
     /// <remarks>
     /// The type of an instrument is <see cref="System.Diagnostics.Metrics.ObservableGauge{T}"/>.
     /// </remarks>
-    public const string MemoryUtilization = "dotnet.process.memory.virtual.utilization";
+    public const string ContainerMemoryLimitUtilization = "container.memory.limit.utilization";
 }