[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 a value indicating whether or not CPU time should be further broken down by its states.
+    /// </summary>
+    /// <remarks>The CPU state could be one of the following types: system, user, or wait.</remarks>
+    public bool CpuStatesEnabled { get; set; }
 }

src/OpenTelemetry.Instrumentation.Process/ProcessMetrics.cs

@@ -14,6 +14,7 @@
 // limitations under the License.
 // </copyright>
 
+using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using System.Reflection;
 using Diagnostics = System.Diagnostics;
@@ -24,38 +25,86 @@ 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()
+    private static readonly string[] CpuStates = new string[] { "system", "user", "wait" };
+
+    /// <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();
+        }
+
+        public long GetMemoryUsage()
+        {
+            return this.currentProcess.WorkingSet64;
+        }
+
+        public long GetVirtualMemoryUsage()
+        {
+            return this.currentProcess.VirtualMemorySize64;
+        }
+
+        public int 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<int>[] GetProcessorCpuTimeWithBreakdown()
+        {
+            Measurement<int>[] measurements = new Measurement<int>[3];
+            var priviledgedCpuTime = this.currentProcess.PrivilegedProcessorTime.Seconds;
+            var userCpuTime = this.currentProcess.UserProcessorTime.Seconds;
+
+            measurements[0] = new(priviledgedCpuTime, new KeyValuePair<string, object>("state", CpuStates[0]));
+            measurements[1] = new(userCpuTime, new KeyValuePair<string, object>("state", CpuStates[1]));
+            measurements[2] = new(this.currentProcess.TotalProcessorTime.Seconds - priviledgedCpuTime - userCpuTime, new KeyValuePair<string, object>("state", CpuStates[2]));
+
+            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);
     }
 }