Add support for System.Diagnostics.Metrics in dotnet-monitor's collector

src/Microsoft.Diagnostics.Monitoring.EventPipe/Configuration/MetricSourceConfiguration.cs

@@ -16,6 +16,7 @@ namespace Microsoft.Diagnostics.Monitoring.EventPipe
     public sealed class MetricSourceConfiguration : MonitoringSourceConfiguration
     {
         private readonly IList<EventPipeProvider> _eventPipeProviders;
+        public string SessionId { get; private set; }
 
         public MetricSourceConfiguration(float metricIntervalSeconds, IEnumerable<string> customProviderNames)
         {
@@ -45,6 +46,37 @@ public MetricSourceConfiguration(float metricIntervalSeconds, IEnumerable<string
                })).ToList();
         }
 
+        public MetricSourceConfiguration(float metricIntervalSeconds, IEnumerable<string> customProviderNames, int maxHistograms, int maxTimeSeries) : this(metricIntervalSeconds, customProviderNames)
+        {
+            const long TimeSeriesValues = 0x2;
+            StringBuilder metrics = new StringBuilder();
+            foreach (string provider in customProviderNames)
+            {
+                if (metrics.Length != 0)
+                {
+                    metrics.Append(",");
+                }
+
+                metrics.Append(provider);
+            }
+
+            SessionId = Guid.NewGuid().ToString();
+
+            EventPipeProvider metricsEventSourceProvider =
+                new EventPipeProvider("System.Diagnostics.Metrics", EventLevel.Informational, TimeSeriesValues,
+                    new Dictionary<string, string>()
+                    {
+                        { "SessionId", SessionId },
+                        { "Metrics", metrics.ToString() },
+                        { "RefreshInterval", MetricIntervalSeconds.ToString() },
+                        { "MaxTimeSeries", maxTimeSeries.ToString() },
+                        { "MaxHistograms", maxHistograms.ToString() }
+                    }
+                );
+
+            _eventPipeProviders = _eventPipeProviders.Append(metricsEventSourceProvider).ToArray();
+        }
+
         private string MetricIntervalSeconds { get; }
 
         public override IList<EventPipeProvider> GetProviders() => _eventPipeProviders;

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

@@ -44,6 +44,12 @@ public bool IsIncluded(string providerName, string counterName, int intervalMill
             {
                 return false;
             }
+
+            return IsIncluded(providerName, counterName);
+        }
+
+        public bool IsIncluded(string providerName, string counterName)
+        {
             if (_enabledCounters.Count == 0)
             {
                 return true;

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

@@ -8,14 +8,11 @@
 
 namespace Microsoft.Diagnostics.Monitoring.EventPipe
 {
+    /// <summary>
+    /// TODO This is currently a duplication of the src\Tools\dotnet-counters\CounterPayload.cs stack. The two will be unified in a separate change.
+    /// </summary>
     internal class CounterPayload : ICounterPayload
     {
-#if NETSTANDARD
-        private static readonly IReadOnlyDictionary<string, string> Empty = new ReadOnlyDictionary<string, string>(new Dictionary<string, string>(0));
-#else
-        private static readonly IReadOnlyDictionary<string, string> Empty = System.Collections.Immutable.ImmutableDictionary<string, string>.Empty;
-#endif
-
         public CounterPayload(DateTime timestamp,
             string provider,
             string name,
@@ -24,7 +21,7 @@ public CounterPayload(DateTime timestamp,
             double value,
             CounterType counterType,
             float interval,
-            Dictionary<string, string> metadata)
+            string metadata)
         {
             Timestamp = timestamp;
             Name = name;
@@ -34,14 +31,27 @@ public CounterPayload(DateTime timestamp,
             CounterType = counterType;
             Provider = provider;
             Interval = interval;
-            Metadata = metadata ?? Empty;
+            Metadata = metadata;
+            EventType = EventType.Gauge;
+        }
+
+        // Copied from dotnet-counters
+        public CounterPayload(string providerName, string name, string displayName, string displayUnits, string metadata, double value, DateTime timestamp, string type, EventType eventType)
+        {
+            Provider = providerName;
+            Name = name;
+            Metadata = metadata;
+            Value = value;
+            Timestamp = timestamp;
+            CounterType = (CounterType)Enum.Parse(typeof(CounterType), type);
+            EventType = eventType;
         }
 
         public string Namespace { get; }
 
         public string Name { get; }
 
-        public string DisplayName { get; }
+        public string DisplayName { get; protected set; }
 
         public string Unit { get; }
 
@@ -55,6 +65,77 @@ public CounterPayload(DateTime timestamp,
 
         public string Provider { get; }
 
-        public IReadOnlyDictionary<string, string> Metadata { get; }
+        public string Metadata { get; }
+
+        public EventType EventType { get; set; }
+    }
+
+    internal class GaugePayload : CounterPayload
+    {
+        public GaugePayload(string providerName, string name, string displayName, string displayUnits, string metadata, double value, DateTime timestamp) :
+            base(providerName, name, displayName, displayUnits, metadata, value, timestamp, "Metric", EventType.Gauge)
+        {
+            // In case these properties are not provided, set them to appropriate values.
+            string counterName = string.IsNullOrEmpty(displayName) ? name : displayName;
+            DisplayName = !string.IsNullOrEmpty(displayUnits) ? $"{counterName} ({displayUnits})" : counterName;
+        }
+    }
+
+    internal class CounterEndedPayload : CounterPayload
+    {
+        public CounterEndedPayload(string providerName, string name, string displayName, DateTime timestamp)
+            : base(providerName, name, displayName, string.Empty, null, 0.0, timestamp, "Metric", EventType.CounterEnded)
+        {
+
+        }
+    }
+
+    internal class RatePayload : CounterPayload
+    {
+        public RatePayload(string providerName, string name, string displayName, string displayUnits, string metadata, double value, double intervalSecs, DateTime timestamp) :
+            base(providerName, name, displayName, displayUnits, metadata, value, timestamp, "Rate", EventType.Rate)
+        {
+            // In case these properties are not provided, set them to appropriate values.
+            string counterName = string.IsNullOrEmpty(displayName) ? name : displayName;
+            string unitsName = string.IsNullOrEmpty(displayUnits) ? "Count" : displayUnits;
+            string intervalName = intervalSecs.ToString() + " sec";
+            DisplayName = $"{counterName} ({unitsName} / {intervalName})";
+        }
+    }
+
+    internal class PercentilePayload : CounterPayload
+    {
+        public PercentilePayload(string providerName, string name, string displayName, string displayUnits, string metadata, double val, DateTime timestamp) :
+            base(providerName, name, displayName, displayUnits, metadata, val, timestamp, "Metric", EventType.Histogram)
+        {
+            // In case these properties are not provided, set them to appropriate values.
+            string counterName = string.IsNullOrEmpty(displayName) ? name : displayName;
+            DisplayName = !string.IsNullOrEmpty(displayUnits) ? $"{counterName} ({displayUnits})" : counterName;
+        }
+    }
+
+    internal class ErrorPayload : CounterPayload
+    {
+        public ErrorPayload(string errorMessage) : this(errorMessage, DateTime.UtcNow) 
+        {
+        }
+
+        public ErrorPayload(string errorMessage, DateTime timestamp) :
+            base(string.Empty, string.Empty, string.Empty, string.Empty, null, 0.0, timestamp, "Metric", EventType.Error)
+        {
+            ErrorMessage = errorMessage;
+        }
+
+        public string ErrorMessage { get; private set; }
+    }
+
+    // If keep this, should probably put it somewhere else
+    internal enum EventType : int
+    {
+        Rate,
+        Gauge,
+        Histogram,
+        Error,
+        CounterEnded
     }
 }

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

@@ -15,6 +15,7 @@ internal class EventCounterPipeline : EventSourcePipeline<EventPipeCounterPipeli
     {
         private readonly IEnumerable<ICountersLogger> _loggers;
         private readonly CounterFilter _filter;
+        private string _sessionId;
 
         public EventCounterPipeline(DiagnosticsClient client,
             EventPipeCounterPipelineSettings settings,
@@ -38,20 +39,29 @@ public EventCounterPipeline(DiagnosticsClient client,
 
         protected override MonitoringSourceConfiguration CreateConfiguration()
         {
-            return new MetricSourceConfiguration(Settings.CounterIntervalSeconds, _filter.GetProviders());
+            var config = new MetricSourceConfiguration(Settings.CounterIntervalSeconds, _filter.GetProviders(), Settings.MaxHistograms, Settings.MaxTimeSeries);
+
+            _sessionId = config.SessionId;
+
+            return config;
         }
 
         protected override async Task OnEventSourceAvailable(EventPipeEventSource eventSource, Func<Task> stopSessionAsync, CancellationToken token)
         {
-            ExecuteCounterLoggerAction((metricLogger) => metricLogger.PipelineStarted());
+            await ExecuteCounterLoggerActionAsync((metricLogger) => metricLogger.PipelineStarted(token));
 
             eventSource.Dynamic.All += traceEvent =>
             {
                 try
                 {
-                    if (traceEvent.TryGetCounterPayload(_filter, out ICounterPayload counterPayload))
+                    if (traceEvent.TryGetCounterPayload(_filter, _sessionId, out List<ICounterPayload> counterPayload))
                     {
-                        ExecuteCounterLoggerAction((metricLogger) => metricLogger.Log(counterPayload));
+                        ExecuteCounterLoggerAction((metricLogger) => {
+                            foreach (var payload in counterPayload)
+                            {
+                                metricLogger.Log(payload);
+                            }
+                        });
                     }
                 }
                 catch (Exception)
@@ -67,7 +77,21 @@ protected override async Task OnEventSourceAvailable(EventPipeEventSource eventS
 
             await sourceCompletedTaskSource.Task;
 
-            ExecuteCounterLoggerAction((metricLogger) => metricLogger.PipelineStopped());
+            await ExecuteCounterLoggerActionAsync((metricLogger) => metricLogger.PipelineStopped(token));
+        }
+
+        private async Task ExecuteCounterLoggerActionAsync(Func<ICountersLogger, Task> action)
+        {
+            foreach (ICountersLogger logger in _loggers)
+            {
+                try
+                {
+                    await action(logger);
+                }
+                catch (ObjectDisposedException)
+                {
+                }
+            }
         }
 
         private void ExecuteCounterLoggerAction(Action<ICountersLogger> action)

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

@@ -15,6 +15,10 @@ internal class EventPipeCounterPipelineSettings : EventSourcePipelineSettings
         //Do not use TimeSpan here since we may need to synchronize this pipeline interval
         //with a different session and want to make sure the values are identical.
         public float CounterIntervalSeconds { get; set; }
+
+        public int MaxHistograms { get; set; }
+
+        public int MaxTimeSeries { get; set; }
     }
 
     internal class EventPipeCounterGroup

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

@@ -33,8 +33,17 @@ internal interface ICounterPayload
 
         DateTime Timestamp { get; }
 
+        /// <summary>
+        /// The interval between counters. Note this is the actual measure of time elapsed, not the requested interval.
+        /// </summary>
         float Interval { get; }
 
-        IReadOnlyDictionary<string, string> Metadata { get; }
+        /// <summary>
+        /// Optional metadata for counters. Note that normal counters use ':' as a separator character, while System.Diagnostics.Metrics use ';'.
+        /// We do not immediately convert string to Dictionary, since dotnet-counters does not need this conversion.
+        /// </summary>
+        string Metadata { get; }
+
+        EventType EventType { get; set; }
     }
 }

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

@@ -2,20 +2,16 @@
 // 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.Collections.Generic;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.Diagnostics.Monitoring.EventPipe
 {
     internal interface ICountersLogger
     {
-        //TODO Consider making these async.
-
         void Log(ICounterPayload counter);
-        void PipelineStarted();
-        void PipelineStopped();
+
+        Task PipelineStarted(CancellationToken token);
+        Task PipelineStopped(CancellationToken token);
     }
 }