Runtime instrumentation

.github/workflows/package-Instrumentation.Runtime.yml

@@ -0,0 +1,49 @@
+name: Pack OpenTelemetry.Contrib.Instrumentation.Runtime
+
+on:
+  workflow_dispatch:
+    inputs:
+      logLevel:
+        description: 'Log level'
+        required: true
+        default: 'warning'
+  push:
+    tags:
+      - 'Instrumentation.Runtime-*' # trigger when we create a tag with prefix "Instrumentation.Runtime-"
+
+jobs:
+  build-test-pack:
+    runs-on: ${{ matrix.os }}
+    env:
+      PROJECT: OpenTelemetry.Contrib.Instrumentation.Runtime
+
+    strategy:
+      matrix:
+        os: [windows-latest]
+
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0 # fetching all
+
+    - name: Install dependencies
+      run: dotnet restore
+
+    - name: dotnet build ${{env.PROJECT}}
+      run: dotnet build src/${{env.PROJECT}} --configuration Release --no-restore -p:Deterministic=true
+
+    - name: dotnet test ${{env.PROJECT}}
+      run: dotnet test test/${{env.PROJECT}}.Tests
+
+    - name: dotnet pack ${{env.PROJECT}}
+      run: dotnet pack src/${{env.PROJECT}} --configuration Release --no-build
+
+    - name: Publish Artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: ${{env.PROJECT}}-packages
+        path: '**/${{env.PROJECT}}/bin/**/*.*nupkg'
+
+    - name: Publish Nuget
+      run: |
+        nuget push **/${{env.PROJECT}}/bin/**/*.nupkg -Source https://api.nuget.org/v3/index.json -ApiKey ${{ secrets.NUGET_TOKEN }} -SymbolApiKey ${{ secrets.NUGET_TOKEN }}

.github/workflows/pr_build.yml

@@ -14,7 +14,7 @@ jobs:
       fail-fast: false  # ensures the entire test matrix is run, even if one permutation fails
       matrix:
         os: [windows-latest,ubuntu-latest]
-        version: [net461,netcoreapp3.1,net5.0]
+        version: [net461,netcoreapp3.1,net5.0,net6.0]
         exclude:
           - os: ubuntu-latest
             version: net461

opentelemetry-dotnet-contrib.sln

@@ -156,6 +156,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Contrib.Exten
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Contrib.Extensions.PersistentStorage.Tests", "test\OpenTelemetry.Contrib.Extensions.PersistentStorage.Tests\OpenTelemetry.Contrib.Extensions.PersistentStorage.Tests.csproj", "{72EBA81D-2933-417C-8F21-D4CFFD72F530}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenTelemetry.Contrib.Instrumentation.Runtime", "src\OpenTelemetry.Contrib.Instrumentation.Runtime\OpenTelemetry.Contrib.Instrumentation.Runtime.csproj", "{F01E8C75-2791-4DBE-BD7A-5510871EBF56}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenTelemetry.Contrib.Instrumentation.Runtime.Tests", "test\OpenTelemetry.Contrib.Instrumentation.Runtime.Tests\OpenTelemetry.Contrib.Instrumentation.Runtime.Tests.csproj", "{FB907DF7-F3F3-4A07-885D-E5FECAE36BDA}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -305,7 +309,15 @@ Global
 		{72EBA81D-2933-417C-8F21-D4CFFD72F530}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{72EBA81D-2933-417C-8F21-D4CFFD72F530}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{72EBA81D-2933-417C-8F21-D4CFFD72F530}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{72EBA81D-2933-417C-8F21-D4CFFD72F530}.Release|Any CPU.Build.0 = Release|Any CPU
+		{72EBA81D-2933-417C-8F21-D4CFFD72F530}.Release|Any CPU.Build.0 = Release|Any CPU				
+		{F01E8C75-2791-4DBE-BD7A-5510871EBF56}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F01E8C75-2791-4DBE-BD7A-5510871EBF56}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F01E8C75-2791-4DBE-BD7A-5510871EBF56}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F01E8C75-2791-4DBE-BD7A-5510871EBF56}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FB907DF7-F3F3-4A07-885D-E5FECAE36BDA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FB907DF7-F3F3-4A07-885D-E5FECAE36BDA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FB907DF7-F3F3-4A07-885D-E5FECAE36BDA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FB907DF7-F3F3-4A07-885D-E5FECAE36BDA}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -352,7 +364,9 @@ Global
 		{6B3AA3F2-89A7-433F-918A-1E5E6AAF8423} = {8D11A34C-D0EF-4DE1-8230-32168E67044D}
 		{D52558C8-B7BF-4F59-A0FA-9AA629E68012} = {2097345F-4DD3-477D-BC54-A922F9B2B402}
 		{433C59A3-D535-421E-BA7F-9BCE0D4A3D25} = {22DF5DC0-1290-4E83-A9D8-6BB7DE3B3E63}
-		{72EBA81D-2933-417C-8F21-D4CFFD72F530} = {2097345F-4DD3-477D-BC54-A922F9B2B402}
+		{72EBA81D-2933-417C-8F21-D4CFFD72F530} = {2097345F-4DD3-477D-BC54-A922F9B2B402}			
+		{F01E8C75-2791-4DBE-BD7A-5510871EBF56} = {22DF5DC0-1290-4E83-A9D8-6BB7DE3B3E63}
+		{FB907DF7-F3F3-4A07-885D-E5FECAE36BDA} = {2097345F-4DD3-477D-BC54-A922F9B2B402}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {B0816796-CDB3-47D7-8C3C-946434DE3B66}

src/OpenTelemetry.Contrib.Instrumentation.Runtime/AssemblyInfo.cs

@@ -0,0 +1,23 @@
+// <copyright file="AssemblyInfo.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System.Runtime.CompilerServices;
+
+#if SIGNED
+[assembly: InternalsVisibleTo("OpenTelemetry.Contrib.Instrumentation.Runtime.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010051c1562a090fb0c9f391012a32198b5e5d9a60e9b80fa2d7b434c9e5ccb7259bd606e66f9660676afc6692b8cdc6793d190904551d2103b7b22fa636dcbb8208839785ba402ea08fc00c8f1500ccef28bbf599aa64ffb1e1d5dc1bf3420a3777badfe697856e9d52070a50c3ea5821c80bef17ca3acffa28f89dd413f096f898")]
+#else
+[assembly: InternalsVisibleTo("OpenTelemetry.Contrib.Instrumentation.Runtime.Tests")]
+#endif

src/OpenTelemetry.Contrib.Instrumentation.Runtime/Implementation/AssembliesInstrumentation.cs

@@ -0,0 +1,33 @@
+// <copyright file="AssembliesInstrumentation.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System;
+using System.Diagnostics.Metrics;
+
+namespace OpenTelemetry.Contrib.Instrumentation.Runtime.Implementation
+{
+    internal class AssembliesInstrumentation : IRuntimeInstrumentation
+    {
+        private readonly Meter meter;
+        private readonly ObservableCounter<int> assemblyCounter;
+
+        public AssembliesInstrumentation(RuntimeMetricsOptions options, Meter meter)
+        {
+            this.meter = meter;
+            this.assemblyCounter = meter.CreateObservableCounter($"{options.MetricPrefix}assembly_count", () => AppDomain.CurrentDomain.GetAssemblies().Length, description: "Number of Assemblies Loaded");
+        }
+    }
+}

src/OpenTelemetry.Contrib.Instrumentation.Runtime/Implementation/GcInstrumentation.cs

@@ -0,0 +1,58 @@
+// <copyright file="GcInstrumentation.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System;
+using System.Diagnostics.Metrics;
+
+namespace OpenTelemetry.Contrib.Instrumentation.Runtime.Implementation
+{
+    internal class GcInstrumentation : IRuntimeInstrumentation
+    {
+        private readonly Meter meter;
+        private readonly ObservableGauge<double> gcHeapSizeCounter;
+        private readonly ObservableGauge<int> gen0GCCounter;
+        private readonly ObservableGauge<int> gen1GCCounter;
+        private readonly ObservableGauge<int> gen2GCCounter;
+        private readonly ObservableCounter<long> allocRateCounter;
+        private readonly ObservableCounter<double> fragmentationCounter;
+
+#if NET6_0_OR_GREATER
+        private readonly ObservableCounter<double> committedCounter;
+#endif
+
+        public GcInstrumentation(RuntimeMetricsOptions options, Meter meter)
+        {
+            this.meter = meter;
+
+            this.gcHeapSizeCounter = meter.CreateObservableGauge($"{options.MetricPrefix}gc_heap_size", () => (double)(GC.GetTotalMemory(false) / 1_000_000), "MB", "GC Heap Size");
+            this.gen0GCCounter = meter.CreateObservableGauge($"{options.MetricPrefix}gen_0-gc_count", () => GC.CollectionCount(0), description: "Gen 0 GC Count");
+            this.gen1GCCounter = meter.CreateObservableGauge($"{options.MetricPrefix}gen_1-gc_count", () => GC.CollectionCount(1), description: "Gen 1 GC Count");
+            this.gen2GCCounter = meter.CreateObservableGauge($"{options.MetricPrefix}gen_2-gc_count", () => GC.CollectionCount(2), description: "Gen 2 GC Count");
+            this.allocRateCounter = meter.CreateObservableCounter($"{options.MetricPrefix}alloc_rate", () => GC.GetTotalAllocatedBytes(), "B", "Allocation Rate");
+            this.fragmentationCounter = meter.CreateObservableCounter($"{options.MetricPrefix}gc_fragmentation", GetFragmentation, description: "GC Fragmentation");
+
+#if NET6_0_OR_GREATER
+            this.committedCounter = meter.CreateObservableCounter($"{options.MetricPrefix}gc_committed", () => (double)(GC.GetGCMemoryInfo().TotalCommittedBytes / 1_000_000), "MB", description: "GC Committed Bytes");
+#endif
+        }
+
+        private static double GetFragmentation()
+        {
+            var gcInfo = GC.GetGCMemoryInfo();
+            return gcInfo.HeapSizeBytes != 0 ? gcInfo.FragmentedBytes * 100d / gcInfo.HeapSizeBytes : 0;
+        }
+    }
+}

src/OpenTelemetry.Contrib.Instrumentation.Runtime/Implementation/IRuntimeInstrumentation.cs

@@ -0,0 +1,22 @@
+// <copyright file="IRuntimeInstrumentation.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+namespace OpenTelemetry.Contrib.Instrumentation.Runtime.Implementation
+{
+    internal interface IRuntimeInstrumentation
+    {
+    }
+}

src/OpenTelemetry.Contrib.Instrumentation.Runtime/Implementation/JitInstrumentation.cs

@@ -0,0 +1,38 @@
+// <copyright file="JitInstrumentation.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+#if NET6_0_OR_GREATER
+using System.Diagnostics.Metrics;
+
+namespace OpenTelemetry.Contrib.Instrumentation.Runtime.Implementation
+{
+    internal class JitInstrumentation : IRuntimeInstrumentation
+    {
+        private readonly Meter meter;
+        private readonly ObservableCounter<long> ilBytesJittedCounter;
+        private readonly ObservableCounter<long> methodsJittedCounter;
+        private readonly ObservableGauge<double> jitTimeCounter;
+
+        public JitInstrumentation(RuntimeMetricsOptions options, Meter meter)
+        {
+            this.meter = meter;
+            this.ilBytesJittedCounter = meter.CreateObservableCounter($"{options.MetricPrefix}il_bytes_jitted", () => System.Runtime.JitInfo.GetCompiledILBytes(), "B", description: "IL Bytes Jitted");
+            this.methodsJittedCounter = meter.CreateObservableCounter($"{options.MetricPrefix}methods_jitted_count", () => System.Runtime.JitInfo.GetCompiledMethodCount(), description: "Number of Methods Jitted");
+            this.jitTimeCounter = meter.CreateObservableGauge($"{options.MetricPrefix}time_in_jit", () => System.Runtime.JitInfo.GetCompilationTime().TotalMilliseconds, "ms", description: "Time spent in JIT");
+        }
+    }
+}
+#endif

src/OpenTelemetry.Contrib.Instrumentation.Runtime/Implementation/PerformanceInstrumentation.cs

@@ -0,0 +1,34 @@
+// <copyright file="PerformanceInstrumentation.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System;
+using System.Diagnostics.Metrics;
+
+namespace OpenTelemetry.Contrib.Instrumentation.Runtime.Implementation
+{
+    internal class PerformanceInstrumentation : IRuntimeInstrumentation
+    {
+        private readonly Meter meter;
+        private readonly ObservableGauge<double> workingSetCounter;
+
+        public PerformanceInstrumentation(RuntimeMetricsOptions options, Meter meter)
+        {
+            this.meter = meter;
+
+            this.workingSetCounter = meter.CreateObservableGauge($"{options.MetricPrefix}working_set", () => (double)(Environment.WorkingSet / 1_000_000), "MB", "Working Set");
+        }
+    }
+}

src/OpenTelemetry.Contrib.Instrumentation.Runtime/Implementation/RuntimeInstrumentationEventSource.cs

@@ -0,0 +1,65 @@
+// <copyright file="RuntimeInstrumentationEventSource.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System.Diagnostics.Tracing;
+
+namespace OpenTelemetry.Contrib.Instrumentation.Runtime.Implementation
+{
+    /// <summary>
+    /// EventSource events emitted from the project.
+    /// </summary>
+    [EventSource(Name = "OpenTelemetry-Instrumentation-Runtime")]
+    internal class RuntimeInstrumentationEventSource : EventSource
+    {
+        public static readonly RuntimeInstrumentationEventSource Log = new RuntimeInstrumentationEventSource();
+
+        [Event(1, Level = EventLevel.Informational, Message = @"EventListener initialized successfully.")]
+        public void EventListenerInitializeSuccess()
+        {
+            this.WriteEvent(1);
+        }
+
+        [Event(2, Level = EventLevel.Error, Message = @"EventListener - {0} failed with exception: {1}.")]
+        public void EventListenerError(string stage, string exceptionMessage)
+        {
+            this.WriteEvent(2, stage, exceptionMessage);
+        }
+
+        [Event(3, Message = "Error occurred while processing eventCounter, EventCounter: {0}, Exception: {2}", Level = EventLevel.Error)]
+        public void ErrorEventCounter(string counterName, string exception)
+        {
+            this.WriteEvent(3, counterName, exception);
+        }
+
+        [Event(4, Level = EventLevel.Warning, Message = @"Ignoring event written from EventCounter: {0} as payload is not IDictionary to extract metrics.")]
+        public void IgnoreEventWrittenAsEventPayloadNotParseable(string counterName)
+        {
+            this.WriteEvent(4, counterName);
+        }
+
+        [Event(5, Level = EventLevel.Informational, Message = @"Ignoring event written from Counter: {0} as this counter is not configured to be collected.")]
+        public void IgnoreEventWrittenAsCounterNotInConfiguredList(string counterName)
+        {
+            this.WriteEvent(5, counterName);
+        }
+
+        [Event(6, Level = EventLevel.Warning, Message = @"Parsing event counter failed with exception: {0}.")]
+        public void EventCountersInstrumentationWarning(string exceptionMessage)
+        {
+            this.WriteEvent(6, exceptionMessage);
+        }
+    }
+}