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

src/OpenTelemetry.Instrumentation.Process/ProcessInstrumentationOptions.cs

@@ -21,4 +21,5 @@ namespace OpenTelemetry.Instrumentation.Process;
 /// </summary>
 public class ProcessInstrumentationOptions
 {
+    public bool? ExpandOnCpuStates { 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;
@@ -57,5 +58,74 @@ static ProcessMetrics()
     /// <param name="options">The options to define the metrics.</param>
     public ProcessMetrics(ProcessInstrumentationOptions options)
     {
+        // TODO: change to ObservableUpDownCounter
+        // MeterInstance.CreateObservableGauge(
+        //    $"process.cpu.utilization",
+        //    () => CurrentProcess.TotalProcessorTime.TotalMilliseconds / (Environment.ProcessorCount * (DateTime.Now - CurrentProcess.StartTime).Milliseconds),
+        //    unit: "1",
+        //    description: "Difference in process.cpu.time since the last measurement, divided by the elapsed time and number of CPUs available to the process.");
+
+        // What type should be used for the label?
+        // labels
+        // state, if specified, SHOULD be one of: system, user, wait. A process SHOULD be characterized either by data points with no state labels, or only data points with state labels.
+        // IEnumberable,
+        // List<Measurement<long>>
+        // wait time = totalprocessortime - Process.PrivilegedProcessorTime - Process.userProcessorTime
+
+        if (options.ExpandOnCpuStates == true)
+        {
+           MeterInstance.CreateObservableCounter(
+           $"process.cpu.time",
+           () =>
+           {
+               Measurement<long>[] measurements = new Measurement<long>[3];
+
+               CurrentProcess.Refresh();
+               var priviledgedCpuTime = CurrentProcess.PrivilegedProcessorTime.Seconds;
+               var userCpuTime = CurrentProcess.PrivilegedProcessorTime.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(CurrentProcess.TotalProcessorTime.Seconds - priviledgedCpuTime - userCpuTime, new KeyValuePair<string, object>("state", CPUState.Wait.ToString()));
+
+               return measurements;
+           },
+           unit: "s",
+           description: "Total CPU seconds broken down by different states.");
+        }
+        else
+        {
+           MeterInstance.CreateObservableCounter(
+           $"process.cpu.time",
+           () =>
+           {
+               CurrentProcess.Refresh();
+               return CurrentProcess.TotalProcessorTime.Seconds;
+           },
+           unit: "s",
+           description: "Total CPU seconds broken down by different states.");
+        }
+
+        // TODO: change to ObservableUpDownCounter
+        MeterInstance.CreateObservableGauge(
+            "process.memory.usage",
+            () => CurrentProcess.WorkingSet64,
+            unit: "By",
+            description: "The amount of physical memory in use.");
+
+        // TODO: change to ObservableUpDownCounter
+        MeterInstance.CreateObservableGauge(
+            "process.memory.virtual",
+            () => CurrentProcess.VirtualMemorySize64,
+            unit: "By",
+            description: "The amount of committed virtual memory.");
+
+    }
+
+    private enum CPUState
+    {
+        System,
+        User,
+        Wait,
     }
 }