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(Meter meter)
+        {
+            this.meter = meter;
+            this.assemblyCounter = meter.CreateObservableCounter("assembly-count", () => AppDomain.CurrentDomain.GetAssemblies().Length, description: "Number of Assemblies Loaded");
+        }
+    }
+}

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

@@ -0,0 +1,152 @@
+// <copyright file="EventCounterListener.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.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics.Tracing;
+
+namespace OpenTelemetry.Contrib.Instrumentation.Runtime.Implementation
+{
+    /// <summary>
+    /// EventCounterListener that subscribes to EventSource Events.
+    /// </summary>
+    internal class EventCounterListener : EventListener
+    {
+        private const string EVENTSOURCENAME = "System.Runtime";
+
+        private readonly ConcurrentQueue<EventSource> allEventSourcesCreated = new ConcurrentQueue<EventSource>();
+        private readonly Dictionary<string, string> refreshIntervalDictionary;
+        private readonly bool isInitialized = false;
+
+        // EventSourceNames from which counters are to be collected are the keys for this IDictionary.
+        // The value will be the corresponding ICollection of counter names.
+        private readonly IDictionary<string, ICollection<string>> countersToCollect = new Dictionary<string, ICollection<string>>();
+        private readonly IEventCounterStore eventCounterStore;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EventCounterListener"/> class.
+        /// </summary>
+        /// <param name="eventCounterStore">Instance to store the data to.</param>
+        public EventCounterListener(IEventCounterStore eventCounterStore)
+        {
+            this.eventCounterStore = eventCounterStore ?? throw new ArgumentNullException(nameof(eventCounterStore));
+
+            try
+            {
+                this.refreshIntervalDictionary = new Dictionary<string, string>();
+                this.refreshIntervalDictionary.Add("EventCounterIntervalSec", "1");
+
+                RuntimeInstrumentationEventSource.Log.EventListenerInitializeSuccess();
+                this.isInitialized = true;
+
+                // Go over every EventSource created before we finished initialization, and enable if required.
+                // This will take care of all EventSources created before initialization was done.
+                foreach (var eventSource in this.allEventSourcesCreated)
+                {
+                    this.EnableEventSource(eventSource);
+                }
+            }
+            catch (Exception ex)
+            {
+                RuntimeInstrumentationEventSource.Log.EventListenerError("EventCounterListener Constructor", ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// Processes a new EventSource event.
+        /// </summary>
+        /// <param name="eventData">Event to process.</param>
+        protected override void OnEventWritten(EventWrittenEventArgs eventData)
+        {
+            // Ignore events if initialization not done yet. We may lose the 1st event if it happens before initialization, in multi-thread situations.
+            // Since these are counters, losing the 1st event will not have noticeable impact.
+            if (!this.isInitialized)
+            {
+                return;
+            }
+
+            try
+            {
+                if (eventData.EventSource.Name == EVENTSOURCENAME)
+                {
+                    if (eventData.Payload.Count > 0 && eventData.Payload[0] is IDictionary<string, object> eventPayload)
+                    {
+                        this.ExtractValue(eventPayload);
+                    }
+                    else
+                    {
+                        RuntimeInstrumentationEventSource.Log.IgnoreEventWrittenAsEventPayloadNotParseable(eventData.EventName);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                RuntimeInstrumentationEventSource.Log.ErrorEventCounter(eventData.EventName, ex.ToString());
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void OnEventSourceCreated(EventSource eventSource)
+        {
+            // Keeping track of all EventSources here, as this call may happen before initialization.
+            this.allEventSourcesCreated.Enqueue(eventSource);
+
+            // options might be null when this method gets called
+            // before our constructor was completed
+            if (this.isInitialized)
+            {
+                this.EnableEventSource(eventSource);
+            }
+        }
+
+        private void EnableEventSource(EventSource eventSource)
+        {
+            try
+            {
+                if (eventSource.Name == EVENTSOURCENAME)
+                {
+                    this.EnableEvents(eventSource, EventLevel.Verbose, EventKeywords.All, this.refreshIntervalDictionary);
+                }
+            }
+            catch (Exception ex)
+            {
+                RuntimeInstrumentationEventSource.Log.EventListenerError(eventSource.Name, ex.Message);
+            }
+        }
+
+        private void ExtractValue(IDictionary<string, object> eventPayload)
+        {
+            try
+            {
+                if (eventPayload.TryGetValue("Name", out var p) && p is string counterName)
+                {
+                    if (!this.eventCounterStore.HasSubscription(counterName))
+                    {
+                        RuntimeInstrumentationEventSource.Log.IgnoreEventWrittenAsCounterNotInConfiguredList(counterName);
+                        return;
+                    }
+
+                    this.eventCounterStore.WriteValue(counterName, eventPayload);
+                }
+            }
+            catch (Exception ex)
+            {
+                RuntimeInstrumentationEventSource.Log.EventCountersInstrumentationWarning(ex.Message);
+            }
+        }
+    }
+}