[Instrumentation.Runtime] Add unit tests

test/OpenTelemetry.Instrumentation.Runtime.Tests/RuntimeMetricsTests.cs

@@ -15,6 +15,8 @@
 // </copyright>
 
 using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
 using OpenTelemetry.Metrics;
 using Xunit;
 
@@ -37,6 +39,133 @@ public void RuntimeMetricsAreCaptured()
             meterProvider.ForceFlush(MaxTimeToAllowForFlush);
             Assert.True(exportedItems.Count > 1);
             Assert.StartsWith(MetricPrefix, exportedItems[0].Name);
+
+            var gcCountMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.gc.collections.count");
+            var sumReceived = GetLongSum(gcCountMetric);
+            Assert.True(sumReceived >= 0);
+
+#if NETCOREAPP3_1_OR_GREATER
+            var gcAllocationSizeMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.gc.allocations.size");
+            Assert.True(GetLongSum(gcAllocationSizeMetric) > 0);
+#endif
+
+#if NET6_0_OR_GREATER
+            // Supposedly to pass if no garbage collection occurred before. However one occurred, which is out of control of the code.
+            // Assert.False(exportedItems.Exists(i => i.Name == "process.runtime.dotnet.gc.committed_memory.size"));
+            // Assert.False(exportedItems.Exists(i => i.Name == "process.runtime.dotnet.gc.heap.size"));
+#endif
+
+            var assembliesCountMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.assemblies.count");
+            Assert.True(GetLongSum(assembliesCountMetric) > 0);
+        }
+
+#if NET6_0_OR_GREATER
+        [Fact]
+        public void RuntimeMetrics_GcAvailableAfterFirst()
+        {
+            var exportedItems = new List<Metric>();
+            using var meterProvider = Sdk.CreateMeterProviderBuilder()
+                 .AddRuntimeInstrumentation()
+                 .AddInMemoryExporter(exportedItems)
+                .Build();
+
+            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
+
+            System.GC.Collect(1);
+
+            var gcCommittedMemorySizeMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.gc.committed_memory.size");
+            Assert.True(GetLongSum(gcCommittedMemorySizeMetric) > 0);
+
+            var gcHeapSizeMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.gc.heap.size");
+            Assert.True(GetLongSum(gcHeapSizeMetric) > 0);
+        }
+#endif
+
+#if NET6_0_OR_GREATER
+        [Fact]
+        public void RuntimeMetrics_JitRelatedMetrics()
+        {
+            var exportedItems = new List<Metric>();
+            using var meterProvider = Sdk.CreateMeterProviderBuilder()
+                 .AddRuntimeInstrumentation()
+                 .AddInMemoryExporter(exportedItems)
+                .Build();
+
+            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
+
+            var jitCompiledSizeMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.jit.il_compiled.size");
+            Assert.True(GetLongSum(jitCompiledSizeMetric) > 0);
+
+            var jitMethodsCompiledCountMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.jit.methods_compiled.count");
+            Assert.True(GetLongSum(jitMethodsCompiledCountMetric) > 0);
+
+            var jitCompilationTimeMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.jit.compilation_time");
+            Assert.True(GetLongSum(jitCompilationTimeMetric) > 0);
+        }
+#endif
+
+#if NETCOREAPP3_1_OR_GREATER
+        [Fact]
+        public void RuntimeMetrics_ThreadingRelatedMetrics()
+        {
+            var exportedItems = new List<Metric>();
+            using var meterProvider = Sdk.CreateMeterProviderBuilder()
+                 .AddRuntimeInstrumentation()
+                 .AddInMemoryExporter(exportedItems)
+                .Build();
+
+            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
+
+            var lockContentionCountMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.monitor.lock_contention.count");
+            Assert.True(GetLongSum(lockContentionCountMetric) >= 0);
+
+            var threadCountMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.thread_pool.threads.count");
+            Assert.True(GetLongSum(threadCountMetric) > 0);
+
+            var completedItemsCountMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.thread_pool.completed_items.count");
+            Assert.True(GetLongSum(completedItemsCountMetric) > 0);
+
+            var queueLengthMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.thread_pool.queue.length");
+            Assert.True(GetLongSum(queueLengthMetric) == 0);
+
+            // Create 10 timers to bump timer.count metrics.
+            int timerCount = 10;
+            TimerCallback timerCallback = _ => { };
+            List<Timer> timers = new List<Timer>();
+            for (int i = 0; i < timerCount; i++)
+            {
+                Timer timer = new Timer(timerCallback, null, 1000, 250);
+                timers.Add(timer);
+            }
+
+            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
+
+            var timerCountMetric = exportedItems.First(i => i.Name == "process.runtime.dotnet.timer.count");
+            Assert.True(GetLongSum(timerCountMetric) >= timerCount);
+            for (int i = 0; i < timers.Count; i++)
+            {
+                timers[i].Dispose();
+            }
+        }
+#endif
+
+        private static double GetLongSum(Metric metric)
+        {
+            double sum = 0;
+
+            foreach (ref readonly var metricPoint in metric.GetMetricPoints())
+            {
+                if (metric.MetricType.IsSum())
+                {
+                    sum += metricPoint.GetSumLong();
+                }
+                else
+                {
+                    sum += metricPoint.GetGaugeLastValueLong();
+                }
+            }
+
+            return sum;
         }
     }
 }