Add Windows disk I/O metrics to ResourceMonitoring

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Microsoft.Extensions.Diagnostics.ResourceMonitoring.csproj

@@ -43,6 +43,7 @@
     <PackageReference Include="System.Threading.Tasks.Extensions" Condition="'$(TargetFramework)' == 'net462'" />
     <PackageReference Include="Microsoft.Bcl.HashCode" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <PackageReference Include="System.Collections.Immutable" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))" />
+    <PackageReference Include="System.Diagnostics.PerformanceCounter" />
   </ItemGroup>
 
   <ItemGroup>

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

@@ -33,4 +33,10 @@ public partial class ResourceMonitoringOptions
     /// </remarks>
     [Experimental(diagnosticId: DiagnosticIds.Experiments.ResourceMonitoring, UrlFormat = DiagnosticIds.UrlFormat)]
     public bool UseZeroToOneRangeForMetrics { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether disk I/O metrics should be enabled.
+    /// </summary>
+    [Experimental(diagnosticId: DiagnosticIds.Experiments.ResourceMonitoring, UrlFormat = DiagnosticIds.UrlFormat)]
+    public bool EnableDiskIoMetrics { get; set; }
 }

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

@@ -6,11 +6,13 @@
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Diagnostics.ResourceMonitoring;
 #if !NETFRAMEWORK
+using System.Runtime.Versioning;
 using Microsoft.Extensions.Diagnostics.ResourceMonitoring.Linux;
 using Microsoft.Extensions.Diagnostics.ResourceMonitoring.Linux.Network;
 
 #endif
 using Microsoft.Extensions.Diagnostics.ResourceMonitoring.Windows;
+using Microsoft.Extensions.Diagnostics.ResourceMonitoring.Windows.Disk;
 using Microsoft.Extensions.Diagnostics.ResourceMonitoring.Windows.Interop;
 using Microsoft.Extensions.Diagnostics.ResourceMonitoring.Windows.Network;
 using Microsoft.Shared.DiagnosticIds;
@@ -89,6 +91,9 @@ private static IServiceCollection AddResourceMonitoringInternal(
         return services;
     }
 
+#if NETCOREAPP
+    [SupportedOSPlatform("windows")]
+#endif
     private static ResourceMonitorBuilder AddWindowsProvider(this ResourceMonitorBuilder builder)
     {
         builder.PickWindowsSnapshotProvider();
@@ -97,6 +102,9 @@ private static ResourceMonitorBuilder AddWindowsProvider(this ResourceMonitorBui
             .AddActivatedSingleton<WindowsNetworkMetrics>()
             .AddActivatedSingleton<ITcpStateInfoProvider, WindowsTcpStateInfo>();
 
+        _ = builder.Services
+            .AddActivatedSingleton<WindowsDiskMetrics>();
+
         return builder;
     }
 

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Windows/Disk/WindowsDiskMetrics.cs

@@ -0,0 +1,145 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+using Microsoft.Extensions.Options;
+using Microsoft.Shared.Instruments;
+
+#if NETCOREAPP
+using System.Runtime.Versioning;
+#endif
+
+namespace Microsoft.Extensions.Diagnostics.ResourceMonitoring.Windows.Disk;
+
+#if NETCOREAPP
+[SupportedOSPlatform("windows")]
+#endif
+internal sealed class WindowsDiskMetrics
+{
+    private const string LogicalDiskCategory = "LogicalDisk";
+
+    private const string DeviceKey = "system.device";
+
+    private const string DirectionKey = "disk.io.direction";
+
+    private static readonly KeyValuePair<string, object?> _directionReadTag = new(DirectionKey, "read");
+
+    private static readonly KeyValuePair<string, object?> _directionWriteTag = new(DirectionKey, "write");
+
+    private readonly Dictionary<string, WindowsDiskPerSecondPerfCounters> _perSecondCounters = new();
+
+    public WindowsDiskMetrics(IMeterFactory meterFactory, IOptions<ResourceMonitoringOptions> options)
+    {
+        if (!options.Value.EnableDiskIoMetrics)
+        {
+            return;
+        }
+
+#pragma warning disable CA2000 // Dispose objects before losing scope
+        // We don't dispose the meter because IMeterFactory handles that
+        // It's a false-positive, see: https://github.com/dotnet/roslyn-analyzers/issues/6912.
+        // Related documentation: https://github.com/dotnet/docs/pull/37170
+        Meter meter = meterFactory.Create(ResourceUtilizationInstruments.MeterName);
+#pragma warning restore CA2000 // Dispose objects before losing scope
+
+        InitializeDiskCounters();
+
+        // The metric is aligned with
+        // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/system/system-metrics.md#metric-systemdiskio
+        _ = meter.CreateObservableCounter(
+            ResourceUtilizationInstruments.SystemDiskIo,
+            GetDiskIoMeasurements,
+            unit: "By",
+            description: "Disk bytes transferred");
+
+        // The metric is aligned with
+        // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/system/system-metrics.md#metric-systemdiskoperations
+        _ = meter.CreateObservableCounter(
+            ResourceUtilizationInstruments.SystemDiskOperations,
+            GetDiskOperationMeasurements,
+            unit: "{operation}",
+            description: "Disk operations");
+    }
+
+    private void InitializeDiskCounters()
+    {
+        var diskCategory = new PerformanceCounterCategory(LogicalDiskCategory);
+
+        foreach (string counterName in _perSecondPerformanceCounters)
+        {
+            try
+            {
+                var diskPerfCounter = new WindowsDiskPerSecondPerfCounters(diskCategory, counterName);
+                diskPerfCounter.InitializeDiskCounters();
+                _perSecondCounters.Add(counterName, diskPerfCounter);
+            }
+#pragma warning disable CA1031
+            catch (Exception ex)
+#pragma warning restore CA1031
+            {
+                Debug.WriteLine("Error initializing disk performance counter: " + ex.Message);
+            }
+        }
+    }
+
+    private IEnumerable<Measurement<long>> GetDiskIoMeasurements()
+    {
+        List<Measurement<long>> measurements = [];
+
+        if (_perSecondCounters.TryGetValue(WindowsDiskPerfCounterNames.DiskWriteBytesCounter, out WindowsDiskPerSecondPerfCounters? perSecondWriteCounter))
+        {
+            perSecondWriteCounter.UpdateDiskCounters();
+            foreach (KeyValuePair<string, long> pair in perSecondWriteCounter.TotalCountDict)
+            {
+                measurements.Add(new Measurement<long>(pair.Value, new TagList { _directionWriteTag, new(DeviceKey, pair.Key) }));
+            }
+        }
+
+        if (_perSecondCounters.TryGetValue(WindowsDiskPerfCounterNames.DiskReadBytesCounter, out WindowsDiskPerSecondPerfCounters? perSecondReadCounter))
+        {
+            perSecondReadCounter.UpdateDiskCounters();
+            foreach (KeyValuePair<string, long> pair in perSecondReadCounter.TotalCountDict)
+            {
+                measurements.Add(new Measurement<long>(pair.Value, new TagList { _directionReadTag, new(DeviceKey, pair.Key) }));
+            }
+        }
+
+        return measurements;
+    }
+
+    private IEnumerable<Measurement<long>> GetDiskOperationMeasurements()
+    {
+        List<Measurement<long>> measurements = [];
+
+        if (_perSecondCounters.TryGetValue(WindowsDiskPerfCounterNames.DiskWritesCounter, out WindowsDiskPerSecondPerfCounters? perSecondWriteCounter))
+        {
+            perSecondWriteCounter.UpdateDiskCounters();
+            foreach (KeyValuePair<string, long> pair in perSecondWriteCounter.TotalCountDict)
+            {
+                measurements.Add(new Measurement<long>(pair.Value, new TagList { _directionWriteTag, new(DeviceKey, pair.Key) }));
+            }
+        }
+
+        if (_perSecondCounters.TryGetValue(WindowsDiskPerfCounterNames.DiskReadsCounter, out WindowsDiskPerSecondPerfCounters? perSecondReadCounter))
+        {
+            perSecondReadCounter.UpdateDiskCounters();
+            foreach (KeyValuePair<string, long> pair in perSecondReadCounter.TotalCountDict)
+            {
+                measurements.Add(new Measurement<long>(pair.Value, new TagList { _directionReadTag, new(DeviceKey, pair.Key) }));
+            }
+        }
+
+        return measurements;
+    }
+
+    private static readonly List<string> _perSecondPerformanceCounters =
+    [
+        WindowsDiskPerfCounterNames.DiskWriteBytesCounter,
+        WindowsDiskPerfCounterNames.DiskReadBytesCounter,
+        WindowsDiskPerfCounterNames.DiskWritesCounter,
+        WindowsDiskPerfCounterNames.DiskReadsCounter,
+    ];
+}

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Windows/Disk/WindowsDiskPerSecondPerfCounters.cs

@@ -0,0 +1,76 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+#if NETCOREAPP
+using System.Runtime.Versioning;
+#endif
+
+namespace Microsoft.Extensions.Diagnostics.ResourceMonitoring.Windows.Disk;
+
+#if NETCOREAPP
+[SupportedOSPlatform("windows")]
+#endif
+internal sealed class WindowsDiskPerSecondPerfCounters
+{
+    internal Dictionary<string, long> TotalCountDict { get; } = [];
+
+    private readonly List<PerformanceCounter> _counters = [];
+
+    private readonly PerformanceCounterCategory _category;
+
+    private readonly string _counterName;
+
+    private long _lastTimestamp;
+
+    internal WindowsDiskPerSecondPerfCounters(PerformanceCounterCategory category, string counterName)
+    {
+        _category = category;
+        _counterName = counterName;
+    }
+
+    internal void InitializeDiskCounters()
+    {
+        string[]? instanceNames = _category.GetInstanceNames();
+        foreach (string instance in instanceNames)
+        {
+            // Skip the total instance
+            if (instance.Equals("_Total", StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            // Create counters for each disk
+            _counters.Add(new PerformanceCounter(_category.CategoryName, _counterName, instance));
+            TotalCountDict.Add(instance, 0);
+        }
+
+        foreach (PerformanceCounter counter in _counters)
+        {
+            _ = counter.NextValue();
+        }
+
+#pragma warning disable EA0002
+        _lastTimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+#pragma warning restore EA0002
+    }
+
+    internal void UpdateDiskCounters()
+    {
+#pragma warning disable EA0002
+        long currentTimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+#pragma warning restore EA0002
+        double elapsedTime = (currentTimestamp - _lastTimestamp) / 1000.0; // Convert to seconds
+
+        foreach (PerformanceCounter counter in _counters)
+        {
+            double value = counter.NextValue() * elapsedTime;
+            TotalCountDict[counter.InstanceName] += (long)value;
+        }
+
+        _lastTimestamp = currentTimestamp;
+    }
+}

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Windows/Disk/WindowsDiskPerfCounterNames.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Extensions.Diagnostics.ResourceMonitoring.Windows.Disk;
+
+internal static class WindowsDiskPerfCounterNames
+{
+    internal const string DiskWriteBytesCounter = "Disk Write Bytes/sec";
+
+    internal const string DiskReadBytesCounter = "Disk Read Bytes/sec";
+
+    internal const string DiskWritesCounter = "Disk Writes/sec";
+
+    internal const string DiskReadsCounter = "Disk Reads/sec";
+}

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Windows/Network/WindowsNetworkMetrics.cs

@@ -18,7 +18,7 @@ public WindowsNetworkMetrics(IMeterFactory meterFactory, ITcpStateInfoProvider t
 
 #pragma warning disable CA2000 // Dispose objects before losing scope
         // We don't dispose the meter because IMeterFactory handles that
-        // Is's a false-positive, see: https://github.com/dotnet/roslyn-analyzers/issues/6912.
+        // It's a false-positive, see: https://github.com/dotnet/roslyn-analyzers/issues/6912.
         // Related documentation: https://github.com/dotnet/docs/pull/37170
         var meter = meterFactory.Create(ResourceUtilizationInstruments.MeterName);
 #pragma warning restore CA2000 // Dispose objects before losing scope

src/Shared/Instruments/ResourceUtilizationInstruments.cs

@@ -65,6 +65,22 @@ internal static class ResourceUtilizationInstruments
     /// The type of an instrument is <see cref="System.Diagnostics.Metrics.ObservableUpDownCounter{T}"/>.
     /// </remarks>
     public const string SystemNetworkConnections = "system.network.connections";
+
+    /// <summary>
+    /// The name of an instrument to retrieve disk bytes transferred.
+    /// </summary>
+    /// <remarks>
+    /// The type of an instrument is <see cref="System.Diagnostics.Metrics.ObservableCounter{T}"/>.
+    /// </remarks>
+    public const string SystemDiskIo = "system.disk.io";
+
+    /// <summary>
+    /// The name of an instrument to retrieve disk operations.
+    /// </summary>
+    /// <remarks>
+    /// The type of an instrument is <see cref="System.Diagnostics.Metrics.ObservableCounter{T}"/>.
+    /// </remarks>
+    public const string SystemDiskOperations = "system.disk.operations";
 }
 
 #pragma warning disable CS1574