[Instrumentation.EventCounters] Stabilize and Enable Testing

.github/component_owners.yml

@@ -37,6 +37,7 @@ components:
     - ejsmith
   src/OpenTelemetry.Instrumentation.EventCounters/:
     - hananiel
+    - mic-max
   src/OpenTelemetry.Instrumentation.GrpcCore/:
     - pcwiese
   src/OpenTelemetry.Instrumentation.Hangfire/:
@@ -99,6 +100,7 @@ components:
     - ejsmith
   test/OpenTelemetry.Instrumentation.EventCounters.Tests/:
     - hananiel
+    - mic-max
   test/OpenTelemetry.Instrumentation.GrpcCore.Tests/:
     - pcwiese
   test/OpenTelemetry.Instrumentation.Hangfire.Tests/:

src/OpenTelemetry.Instrumentation.EventCounters/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+* Simplified implementation. EventSources must be explicitly configured to be
+  listened to now.
+  ([#620](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/620))
+
 ## 0.1.0-alpha.1
 
 Released 2022-Jul-12

src/OpenTelemetry.Instrumentation.EventCounters/EventCountersInstrumentationEventSource.cs

@@ -22,25 +22,49 @@ namespace OpenTelemetry.Instrumentation.EventCounters;
 /// EventSource events emitted from the project.
 /// </summary>
 [EventSource(Name = "OpenTelemetry-Instrumentation-EventCounters")]
-internal class EventCountersInstrumentationEventSource : EventSource
+internal sealed class EventCountersInstrumentationEventSource : EventSource
 {
     public static readonly EventCountersInstrumentationEventSource Log = new();
 
-    [Event(1, Message = "Error occurred while processing eventCounter, EventCounter: {0}, Exception: {2}", Level = EventLevel.Error)]
-    public void ErrorEventCounter(string counterName, string exception)
+    [Event(1, Level = EventLevel.Warning, Message = "Duplicate instrument name detected: {0}.")]
+    internal void DuplicateInstrumentNameWarning(string instrumentName)
     {
-        this.WriteEvent(1, counterName, exception);
+        this.WriteEvent(1, instrumentName);
     }
 
-    [Event(2, Level = EventLevel.Warning, Message = @"Ignoring event written from EventSource: {0} as payload is not IDictionary to extract metrics.")]
-    public void IgnoreEventWrittenAsEventPayloadNotParseable(string eventSourceName)
+    [Event(2, Level = EventLevel.Warning, Message = "Invalid instrument name: {0}.")]
+    internal void InvalidInstrumentNameWarning(string instrumentName)
+    {
+        this.WriteEvent(2, instrumentName);
+    }
+
+    [Event(3, Level = EventLevel.Warning, Message = "Error while writing event from source: {0} - {1}.")]
+    internal void ErrorWhileWritingEvent(string eventSourceName, string exceptionMessage)
+    {
+        this.WriteEvent(3, eventSourceName, exceptionMessage);
+    }
+
+    [Event(4, Level = EventLevel.Warning, Message = "Event data payload not parseable from source: {0}.")]
+    internal void IgnoreEventWrittenEventArgsPayloadNotParseable(string eventSourceName)
     {
         this.WriteEvent(4, eventSourceName);
     }
 
-    [Event(3, Level = EventLevel.Warning, Message = @"EventCountersInstrumentation - {0} failed with exception: {1}.")]
-    public void EventCountersInstrumentationWarning(string stage, string exceptionMessage)
+    [Event(5, Level = EventLevel.Warning, Message = "Event data has no name from source: {0}.")]
+    internal void IgnoreEventWrittenEventArgsWithoutName(string eventSourceName)
+    {
+        this.WriteEvent(5, eventSourceName);
+    }
+
+    [Event(6, Level = EventLevel.Warning, Message = "Event data payload problem with values of Mean, Increment from source: {0}.")]
+    internal void IgnoreMeanIncrementConflict(string eventSourceName)
+    {
+        this.WriteEvent(6, eventSourceName);
+    }
+
+    [Event(7, Level = EventLevel.Warning, Message = "Event data has name other than 'EventCounters' from source: {0}.")]
+    internal void IgnoreNonEventCountersName(string eventSourceName)
     {
-        this.WriteEvent(8, stage, exceptionMessage);
+        this.WriteEvent(7, eventSourceName);
     }
 }

src/OpenTelemetry.Instrumentation.EventCounters/EventCountersInstrumentationOptions.cs

@@ -0,0 +1,59 @@
+// <copyright file="EventCountersInstrumentationOptions.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.Generic;
+using System.Linq;
+
+namespace OpenTelemetry.Instrumentation.EventCounters;
+
+/// <summary>
+/// EventCounterListener Options.
+/// </summary>
+public class EventCountersInstrumentationOptions
+{
+    private readonly HashSet<string> eventSourceNames = new();
+
+    /// <summary>
+    /// Gets or sets the subscription interval in seconds for reading values
+    /// from the configured EventCounters.
+    /// </summary>
+    public int RefreshIntervalSecs { get; set; } = 1;
+
+    /// <summary>
+    /// Listens to EventCounters from the given EventSource name.
+    /// </summary>
+    /// <param name="names">The EventSource names to listen to.</param>
+    public void AddEventSources(params string[] names)
+    {
+        if (names.Contains("System.Runtime"))
+        {
+            throw new NotSupportedException("Use the `OpenTelemetry.Instrumentation.Runtime` or `OpenTelemetry.Instrumentation.Process` instrumentations.");
+        }
+
+        this.eventSourceNames.UnionWith(names);
+    }
+
+    /// <summary>
+    /// Returns whether or not an EventSource should be enabled on the EventListener.
+    /// </summary>
+    /// <param name="eventSourceName">The EventSource name.</param>
+    /// <returns><c>true</c> when an EventSource with the name <paramref name="eventSourceName"/> should be enabled.</returns>
+    internal bool ShouldListenToSource(string eventSourceName)
+    {
+        return this.eventSourceNames.Contains(eventSourceName);
+    }
+}