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

src/OpenTelemetry.Instrumentation.Process/ProcessMetrics.cs

@@ -14,8 +14,11 @@
 // limitations under the License.
 // </copyright>
 
+using System;
+using System.Diagnostics;
 using System.Diagnostics.Metrics;
 using System.Reflection;
+using System.Threading.Tasks;
 using Diagnostics = System.Diagnostics;
 
 namespace OpenTelemetry.Instrumentation.Process;
@@ -24,31 +27,41 @@ 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();
+    private const int MeasurementWindowInSeconds = 1;
 
     static ProcessMetrics()
     {
+        InstrumentsValues values = new InstrumentsValues();
+
+        // Refer to the spec for instrument details:
+        // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/semantic_conventions/process-metrics.md#metric-instruments
+
         // 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.");
+            description: "The amount of physical memory in use by the current process.");
 
         // 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.");
+            description: "The amount of committed virtual memory by the current process.");
+
+        MeterInstance.CreateObservableCounter(
+            $"process.cpu.time",
+            () => values.GetCpuTime(),
+            unit: "s",
+            description: "The amount of time that the current process has actively used a CPU to perform computations.");
+
+        // TODO: change to ObservableUpDownCounter
+        MeterInstance.CreateObservableGauge(
+            $"process.cpu.utilization",
+            () => values.GetCpuUtilization(MeasurementWindowInSeconds).Result,
+            unit: "s",
+            description: "Difference in process.cpu.time since the last measurement, divided by the elapsed time and number of CPUs available to the current process.");
     }
 
     /// <summary>
@@ -58,4 +71,42 @@ static ProcessMetrics()
     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 double GetCpuTime()
+        {
+            return this.currentProcess.TotalProcessorTime.TotalSeconds;
+        }
+
+        public async Task<double> GetCpuUtilization(int measurementWindowInSeconds)
+        {
+            var startCpuTime = this.currentProcess.TotalProcessorTime.TotalSeconds;
+            Stopwatch timer = Stopwatch.StartNew();
+
+            await Task.Delay(measurementWindowInSeconds * 1000).ConfigureAwait(false);
+
+            var endCpuTime = this.currentProcess.TotalProcessorTime.TotalSeconds;
+            timer.Stop();
+
+            return (endCpuTime - startCpuTime) / (Environment.ProcessorCount * (timer.ElapsedMilliseconds / 1000));
+        }
+    }
 }

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

@@ -36,10 +36,14 @@ public void ProcessMetricsAreCaptured()
 
         meterProvider.ForceFlush(MaxTimeToAllowForFlush);
 
-        Assert.True(exportedItems.Count == 2);
+        Assert.True(exportedItems.Count == 4);
         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 cpuTimeMetric = exportedItems.FirstOrDefault(i => i.Name == "process.cpu.time");
+        Assert.NotNull(cpuTimeMetric);
+        var cpuUtilizationMetric = exportedItems.FirstOrDefault(i => i.Name == "process.cpu.utilization");
+        Assert.NotNull(cpuUtilizationMetric);
     }
 }