[Instrumentation.Process] Added Cpu related metrics and addressed comments.

src/OpenTelemetry.Instrumentation.Process/.publicApi/netstandard2.0/PublicAPI.Unshipped.txt

@@ -1,4 +1,6 @@
 OpenTelemetry.Instrumentation.Process.ProcessInstrumentationOptions
+OpenTelemetry.Instrumentation.Process.ProcessInstrumentationOptions.CpuStatesEnabled.get -> bool?
+OpenTelemetry.Instrumentation.Process.ProcessInstrumentationOptions.CpuStatesEnabled.set -> void
 OpenTelemetry.Instrumentation.Process.ProcessInstrumentationOptions.ProcessInstrumentationOptions() -> void
 OpenTelemetry.Metrics.MeterProviderBuilderExtensions
 static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddProcessInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Action<OpenTelemetry.Instrumentation.Process.ProcessInstrumentationOptions> configure = null) -> OpenTelemetry.Metrics.MeterProviderBuilder

src/OpenTelemetry.Instrumentation.Process/ProcessInstrumentationOptions.cs

@@ -21,4 +21,9 @@ namespace OpenTelemetry.Instrumentation.Process;
 /// </summary>
 public class ProcessInstrumentationOptions
 {
+    /// <summary>
+    /// Gets or sets the flag indicating whether CPU time should be further broken down by its states.
+    /// The CPU state could be one of the following type: system, user, or wait.
+    /// </summary>
+    public bool? CpuStatesEnabled { get; set; } = false;
 }

src/OpenTelemetry.Instrumentation.Process/ProcessMetrics.cs

@@ -14,6 +14,8 @@
 // limitations under the License.
 // </copyright>
 
+using System;
+using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using System.Reflection;
 using Diagnostics = System.Diagnostics;
@@ -24,38 +26,91 @@ internal class ProcessMetrics
 {
     internal static readonly AssemblyName AssemblyName = typeof(ProcessMetrics).Assembly.GetName();
     internal static readonly Meter MeterInstance = new(AssemblyName.Name, AssemblyName.Version.ToString());
-    private static readonly Diagnostics.Process CurrentProcess = Diagnostics.Process.GetCurrentProcess();
 
-    static ProcessMetrics()
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ProcessMetrics"/> class.
+    /// </summary>
+    /// <param name="options">The options to define the metrics.</param>
+    public ProcessMetrics(ProcessInstrumentationOptions? options)
     {
+        InstrumentsValues values = new InstrumentsValues();
+
         // TODO: change to ObservableUpDownCounter
         MeterInstance.CreateObservableGauge(
             "process.memory.usage",
-            () =>
-            {
-                CurrentProcess.Refresh();
-                return CurrentProcess.WorkingSet64;
-            },
+            () => values.GetMemoryUsage(),
             unit: "By",
             description: "The amount of physical memory in use.");
 
         // TODO: change to ObservableUpDownCounter
         MeterInstance.CreateObservableGauge(
             "process.memory.virtual",
-            () =>
-            {
-                CurrentProcess.Refresh();
-                return CurrentProcess.VirtualMemorySize64;
-            },
+            () => values.GetVirtualMemoryUsage(),
             unit: "By",
             description: "The amount of committed virtual memory.");
+
+        if (options.CpuStatesEnabled == false)
+        {
+            MeterInstance.CreateObservableCounter(
+            $"process.cpu.time",
+            () => values.GetProcessorCpuTime(),
+            unit: "s",
+            description: "Total CPU seconds.");
+        }
+        else
+        {
+            MeterInstance.CreateObservableCounter(
+            $"process.cpu.time",
+            () => values.GetProcessorCpuTimeWithBreakdown(),
+            unit: "s",
+            description: "Total CPU seconds broken down by different states.");
+        }
     }
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ProcessMetrics"/> class.
-    /// </summary>
-    /// <param name="options">The options to define the metrics.</param>
-    public ProcessMetrics(ProcessInstrumentationOptions options)
+    private class InstrumentsValues
     {
+        private readonly Diagnostics.Process currentProcess = Diagnostics.Process.GetCurrentProcess();
+
+        public InstrumentsValues()
+        {
+            this.currentProcess.Refresh();
+        }
+
+        private enum CpuState
+        {
+            System,
+            User,
+            Wait,
+        }
+
+        public long GetMemoryUsage()
+        {
+            return this.currentProcess.WorkingSet64;
+        }
+
+        public long GetVirtualMemoryUsage()
+        {
+            return this.currentProcess.VirtualMemorySize64;
+        }
+
+        public long GetProcessorCpuTime()
+        {
+            return this.currentProcess.TotalProcessorTime.Seconds;
+        }
+
+        // See spec:
+        // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/semantic_conventions/process-metrics.md#metric-instruments
+        public Measurement<long>[] GetProcessorCpuTimeWithBreakdown()
+        {
+            Measurement<long>[] measurements = new Measurement<long>[Enum.GetNames(typeof(CpuState)).Length];
+            var priviledgedCpuTime = this.currentProcess.PrivilegedProcessorTime.Seconds;
+            var userCpuTime = this.currentProcess.UserProcessorTime.Seconds;
+
+            measurements[(int)CpuState.System] = new(priviledgedCpuTime, new KeyValuePair<string, object>("state", CpuState.System.ToString()));
+            measurements[(int)CpuState.User] = new(userCpuTime, new KeyValuePair<string, object>("state", CpuState.User.ToString()));
+            measurements[(int)CpuState.Wait] = new(this.currentProcess.TotalProcessorTime.Seconds - priviledgedCpuTime - userCpuTime, new KeyValuePair<string, object>("state", CpuState.Wait.ToString()));
+
+            return measurements;
+        }
     }
 }

test/OpenTelemetry.Instrumentation.Process.Tests/ProcessMetricsTests.cs

@@ -36,10 +36,12 @@ public void ProcessMetricsAreCaptured()
 
         meterProvider.ForceFlush(MaxTimeToAllowForFlush);
 
-        Assert.True(exportedItems.Count == 2);
+        Assert.True(exportedItems.Count == 3);
         var physicalMemoryMetric = exportedItems.FirstOrDefault(i => i.Name == "process.memory.usage");
         Assert.NotNull(physicalMemoryMetric);
         var virtualMemoryMetric = exportedItems.FirstOrDefault(i => i.Name == "process.memory.virtual");
         Assert.NotNull(virtualMemoryMetric);
+        var processCpuTimeMetric = exportedItems.FirstOrDefault(i => i.Name == "process.cpu.time");
+        Assert.NotNull(processCpuTimeMetric);
     }
 }