Initial trace event trigger implementation and tests.

eng/Versions.props

@@ -45,6 +45,7 @@
     <MicrosoftExtensionsLoggingEventSourceVersion>5.0.1</MicrosoftExtensionsLoggingEventSourceVersion>
     <SystemCommandLineVersion>2.0.0-beta1.20468.1</SystemCommandLineVersion>
     <SystemCommandLineRenderingVersion>2.0.0-beta1.20074.1</SystemCommandLineRenderingVersion>
+    <SystemComponentModelAnnotationsVersion>5.0.0</SystemComponentModelAnnotationsVersion>
     <SystemMemoryVersion>4.5.4</SystemMemoryVersion>
     <SystemTextEncodingsWebVersion>4.7.2</SystemTextEncodingsWebVersion>
     <SystemTextJsonVersion>4.7.1</SystemTextJsonVersion>

src/Microsoft.Diagnostics.Monitoring.EventPipe/Counters/CounterFilter.cs

@@ -11,13 +11,16 @@ namespace Microsoft.Diagnostics.Monitoring.EventPipe
     internal sealed class CounterFilter
     {
         private Dictionary<string, List<string>> _enabledCounters;
+        private int _intervalMilliseconds;
 
-        public static CounterFilter AllCounters { get; } = new CounterFilter();
+        public static CounterFilter AllCounters(int counterIntervalSeconds)
+            => new CounterFilter(counterIntervalSeconds);
 
-        public CounterFilter()
+        public CounterFilter(int intervalSeconds)
         {
             //Provider names are not case sensitive, but counter names are.
             _enabledCounters = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
+            _intervalMilliseconds = intervalSeconds * 1000;
         }
 
         // Called when we want to enable all counters under a provider name.
@@ -33,8 +36,12 @@ public void AddFilter(string providerName, string[] counters)
 
         public IEnumerable<string> GetProviders() => _enabledCounters.Keys;
 
-        public bool IsIncluded(string providerName, string counterName)
+        public bool IsIncluded(string providerName, string counterName, int interval)
         {
+            if (_intervalMilliseconds != interval)
+            {
+                return false;
+            }
             if (_enabledCounters.Count == 0)
             {
                 return true;

src/Microsoft.Diagnostics.Monitoring.EventPipe/Counters/EventCounterPipeline.cs

@@ -24,15 +24,15 @@ public EventCounterPipeline(DiagnosticsClient client,
 
             if (settings.CounterGroups.Length > 0)
             {
-                _filter = new CounterFilter();
+                _filter = new CounterFilter(CounterIntervalSeconds);
                 foreach (var counterGroup in settings.CounterGroups)
                 {
                     _filter.AddFilter(counterGroup.ProviderName, counterGroup.CounterNames);
                 }
             }
             else
             {
-                _filter = CounterFilter.AllCounters;
+                _filter = CounterFilter.AllCounters(CounterIntervalSeconds);
             }
         }
 
@@ -49,56 +49,8 @@ protected override async Task OnEventSourceAvailable(EventPipeEventSource eventS
             {
                 try
                 {
-                    // Metrics
-                    if (traceEvent.EventName.Equals("EventCounters"))
+                    if (traceEvent.TryGetCounterPayload(_filter, out ICounterPayload counterPayload))
                     {
-                        IDictionary<string, object> payloadVal = (IDictionary<string, object>)(traceEvent.PayloadValue(0));
-                        IDictionary<string, object> payloadFields = (IDictionary<string, object>)(payloadVal["Payload"]);
-
-                        //Make sure we are part of the requested series. If multiple clients request metrics, all of them get the metrics.
-                        string series = payloadFields["Series"].ToString();
-                        if (GetInterval(series) != CounterIntervalSeconds * 1000)
-                        {
-                            return;
-                        }
-
-                        string counterName = payloadFields["Name"].ToString();
-                        if (!_filter.IsIncluded(traceEvent.ProviderName, counterName))
-                        {
-                            return;
-                        }
-
-                        float intervalSec = (float)payloadFields["IntervalSec"];
-                        string displayName = payloadFields["DisplayName"].ToString();
-                        string displayUnits = payloadFields["DisplayUnits"].ToString();
-                        double value = 0;
-                        CounterType counterType = CounterType.Metric;
-
-                        if (payloadFields["CounterType"].Equals("Mean"))
-                        {
-                            value = (double)payloadFields["Mean"];
-                        }
-                        else if (payloadFields["CounterType"].Equals("Sum"))
-                        {
-                            counterType = CounterType.Rate;
-                            value = (double)payloadFields["Increment"];
-                            if (string.IsNullOrEmpty(displayUnits))
-                            {
-                                displayUnits = "count";
-                            }
-                            //TODO Should we make these /sec like the dotnet-counters tool?
-                        }
-
-                        // Note that dimensional data such as pod and namespace are automatically added in prometheus and azure monitor scenarios.
-                        // We no longer added it here.
-                        var counterPayload = new CounterPayload(traceEvent.TimeStamp,
-                            traceEvent.ProviderName,
-                            counterName, displayName,
-                            displayUnits,
-                            value,
-                            counterType,
-                            intervalSec);
-
                         ExecuteCounterLoggerAction((metricLogger) => metricLogger.Log(counterPayload));
                     }
                 }
@@ -118,17 +70,6 @@ protected override async Task OnEventSourceAvailable(EventPipeEventSource eventS
             ExecuteCounterLoggerAction((metricLogger) => metricLogger.PipelineStopped());
         }
 
-        private static int GetInterval(string series)
-        {
-            const string comparison = "Interval=";
-            int interval = 0;
-            if (series.StartsWith(comparison, StringComparison.OrdinalIgnoreCase))
-            {
-                int.TryParse(series.Substring(comparison.Length), out interval);
-            }
-            return interval;
-        }
-
         private void ExecuteCounterLoggerAction(Action<ICountersLogger> action)
         {
             foreach (ICountersLogger logger in _loggers)

src/Microsoft.Diagnostics.Monitoring.EventPipe/Counters/TraceEventExtensions.cs

@@ -0,0 +1,78 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Diagnostics.Tracing;
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Diagnostics.Monitoring.EventPipe
+{
+    internal static class TraceEventExtensions
+    {
+        public static bool TryGetCounterPayload(this TraceEvent traceEvent, CounterFilter filter, out ICounterPayload payload)
+        {
+            payload = null;
+
+            if ("EventCounters".Equals(traceEvent.EventName))
+            {
+                IDictionary<string, object> payloadVal = (IDictionary<string, object>)(traceEvent.PayloadValue(0));
+                IDictionary<string, object> payloadFields = (IDictionary<string, object>)(payloadVal["Payload"]);
+
+                //Make sure we are part of the requested series. If multiple clients request metrics, all of them get the metrics.
+                string series = payloadFields["Series"].ToString();
+                string counterName = payloadFields["Name"].ToString();
+                if (!filter.IsIncluded(traceEvent.ProviderName, counterName, GetInterval(series)))
+                {
+                    return false;
+                }
+
+                float intervalSec = (float)payloadFields["IntervalSec"];
+                string displayName = payloadFields["DisplayName"].ToString();
+                string displayUnits = payloadFields["DisplayUnits"].ToString();
+                double value = 0;
+                CounterType counterType = CounterType.Metric;
+
+                if (payloadFields["CounterType"].Equals("Mean"))
+                {
+                    value = (double)payloadFields["Mean"];
+                }
+                else if (payloadFields["CounterType"].Equals("Sum"))
+                {
+                    counterType = CounterType.Rate;
+                    value = (double)payloadFields["Increment"];
+                    if (string.IsNullOrEmpty(displayUnits))
+                    {
+                        displayUnits = "count";
+                    }
+                    //TODO Should we make these /sec like the dotnet-counters tool?
+                }
+
+                // Note that dimensional data such as pod and namespace are automatically added in prometheus and azure monitor scenarios.
+                // We no longer added it here.
+                payload = new CounterPayload(
+                    traceEvent.TimeStamp,
+                    traceEvent.ProviderName,
+                    counterName, displayName,
+                    displayUnits,
+                    value,
+                    counterType,
+                    intervalSec);
+                return true;
+            }
+
+            return false;
+        }
+
+        private static int GetInterval(string series)
+        {
+            const string comparison = "Interval=";
+            int interval = 0;
+            if (series.StartsWith(comparison, StringComparison.OrdinalIgnoreCase))
+            {
+                int.TryParse(series.Substring(comparison.Length), out interval);
+            }
+            return interval;
+        }
+    }
+}

src/Microsoft.Diagnostics.Monitoring.EventPipe/Microsoft.Diagnostics.Monitoring.EventPipe.csproj

@@ -29,6 +29,7 @@
     <PackageReference Include="Microsoft.Diagnostics.Tracing.TraceEvent" Version="$(MicrosoftDiagnosticsTracingTraceEventVersion)" />
     <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="$(MicrosoftExtensionsLoggingVersion)" />
+    <PackageReference Include="System.ComponentModel.Annotations" Version="$(SystemComponentModelAnnotationsVersion)" />
     <PackageReference Include="System.Text.Encodings.Web" Version="$(SystemTextEncodingsWebVersion)" />
     <PackageReference Include="System.Text.Json" Version="$(SystemTextJsonVersion)" />
   </ItemGroup>

src/Microsoft.Diagnostics.Monitoring.EventPipe/Triggers/EventCounter/EventCounterTrigger.cs

@@ -0,0 +1,71 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Diagnostics.Tracing;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace Microsoft.Diagnostics.Monitoring.EventPipe.Triggers.EventCounter
+{
+    /// <summary>
+    /// Trigger that detects when the specified event source counter value is held
+    /// above, below, or between threshold values for a specified duration of time.
+    /// </summary>
+    internal sealed class EventCounterTrigger :
+        ITraceEventTrigger
+    {
+        private readonly CounterFilter _filter;
+        private readonly EventCounterTriggerImpl _impl;
+        private readonly string _providerName;
+
+        public EventCounterTrigger(EventCounterTriggerSettings settings)
+        {
+            if (null == settings)
+            {
+                throw new ArgumentNullException(nameof(settings));
+            }
+
+            Validate(settings);
+
+            _filter = new CounterFilter(settings.CounterIntervalSeconds);
+            _filter.AddFilter(settings.ProviderName, new string[] { settings.CounterName });
+
+            _impl = new(settings);
+
+            _providerName = settings.ProviderName;
+        }
+
+        public IDictionary<string, IEnumerable<string>> GetProviderEventMap()
+        {
+            return new Dictionary<string, IEnumerable<string>>()
+            {
+                { _providerName, new string[] { "EventCounters" } }
+            };
+        }
+
+        public bool HasSatisfiedCondition(TraceEvent traceEvent)
+        {
+            // Filter to the counter of interest before forwarding to the implementation
+            if (traceEvent.TryGetCounterPayload(_filter, out ICounterPayload payload))
+            {
+                return _impl.HasSatisfiedCondition(payload);
+            }
+            return false;
+        }
+
+        public static MonitoringSourceConfiguration CreateConfiguration(EventCounterTriggerSettings settings)
+        {
+            Validate(settings);
+
+            return new MetricSourceConfiguration(settings.CounterIntervalSeconds, new string[] { settings.ProviderName });
+        }
+
+        private static void Validate(EventCounterTriggerSettings settings)
+        {
+            ValidationContext context = new(settings);
+            Validator.ValidateObject(settings, context, validateAllProperties: true);
+        }
+    }
+}

src/Microsoft.Diagnostics.Monitoring.EventPipe/Triggers/EventCounter/EventCounterTriggerFactory.cs

@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime;
+
+namespace Microsoft.Diagnostics.Monitoring.EventPipe.Triggers.EventCounter
+{
+    /// <summary>
+    /// The trigger factory for the <see cref="EventCounterTrigger"/>.
+    /// </summary>
+    internal sealed class EventCounterTriggerFactory :
+        ITraceEventTriggerFactory<EventCounterTriggerSettings>
+    {
+        public ITraceEventTrigger Create(EventCounterTriggerSettings settings)
+        {
+            return new EventCounterTrigger(settings);
+        }
+    }
+}