Add Support For Multiplexing System.Diagnostics.Metrics for Dotnet Monitor and Dotnet Counters

src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/AggregationManager.cs

@@ -21,17 +21,17 @@ internal sealed class AggregationManager
         // these fields are modified after construction and accessed on multiple threads, use lock(this) to ensure the data
         // is synchronized
         private readonly List<Predicate<Instrument>> _instrumentConfigFuncs = new();
-        private TimeSpan _collectionPeriod;
+        public TimeSpan CollectionPeriod { get; private set; }
 
+        public int MaxTimeSeries { get; }
+        public int MaxHistograms { get; }
+        private Dictionary<Instrument, bool> _instruments = new();
         private readonly ConcurrentDictionary<Instrument, InstrumentState> _instrumentStates = new();
         private readonly CancellationTokenSource _cts = new();
         private Thread? _collectThread;
         private readonly MeterListener _listener;
         private int _currentTimeSeries;
         private int _currentHistograms;
-
-        private readonly int _maxTimeSeries;
-        private readonly int _maxHistograms;
         private readonly Action<Instrument, LabeledAggregationStatistics> _collectMeasurement;
         private readonly Action<DateTime, DateTime> _beginCollection;
         private readonly Action<DateTime, DateTime> _endCollection;
@@ -59,8 +59,8 @@ public AggregationManager(
             Action histogramLimitReached,
             Action<Exception> observableInstrumentCallbackError)
         {
-            _maxTimeSeries = maxTimeSeries;
-            _maxHistograms = maxHistograms;
+            MaxTimeSeries = maxTimeSeries;
+            MaxHistograms = maxHistograms;
             _collectMeasurement = collectMeasurement;
             _beginCollection = beginCollection;
             _endCollection = endCollection;
@@ -73,24 +73,10 @@ public AggregationManager(
             _histogramLimitReached = histogramLimitReached;
             _observableInstrumentCallbackError = observableInstrumentCallbackError;
 
-            _listener = new MeterListener()
-            {
-                InstrumentPublished = (instrument, listener) =>
-                {
-                    _instrumentPublished(instrument);
-                    InstrumentState? state = GetInstrumentState(instrument);
-                    if (state != null)
-                    {
-                        _beginInstrumentMeasurements(instrument);
-                        listener.EnableMeasurementEvents(instrument, state);
-                    }
-                },
-                MeasurementsCompleted = (instrument, cookie) =>
-                {
-                    _endInstrumentMeasurements(instrument);
-                    RemoveInstrumentState(instrument);
-                }
-            };
+            _listener = new MeterListener();
+            _listener.InstrumentPublished += PublishedInstrument;
+            _listener.MeasurementsCompleted += CompletedMeasurements;
+
             _listener.SetMeasurementEventCallback<double>((i, m, l, c) => ((InstrumentState)c!).Update((double)m, l));
             _listener.SetMeasurementEventCallback<float>((i, m, l, c) => ((InstrumentState)c!).Update((double)m, l));
             _listener.SetMeasurementEventCallback<long>((i, m, l, c) => ((InstrumentState)c!).Update((double)m, l));
@@ -124,16 +110,42 @@ public AggregationManager SetCollectionPeriod(TimeSpan collectionPeriod)
             Debug.Assert(collectionPeriod.TotalSeconds >= MinCollectionTimeSecs);
             lock (this)
             {
-                _collectionPeriod = collectionPeriod;
+                CollectionPeriod = collectionPeriod;
             }
             return this;
         }
 
+        private void CompletedMeasurements(Instrument instrument, object? cookie)
+        {
+            _instruments.Remove(instrument);
+            _endInstrumentMeasurements(instrument);
+            RemoveInstrumentState(instrument);
+        }
+
+        private void PublishedInstrument(Instrument instrument, MeterListener _)
+        {
+            _instrumentPublished(instrument);
+            InstrumentState? state = GetInstrumentState(instrument);
+            if (state != null)
+            {
+                _beginInstrumentMeasurements(instrument);
+
+                if (!_instruments.ContainsKey(instrument))
+                {
+                    // This has side effects that prompt MeasurementsCompleted
+                    // to be called if this is called multiple times on an
+                    // instrument in a shared MetricsEventSource.
+                    _listener.EnableMeasurementEvents(instrument, state);
+                    _instruments.Add(instrument, true);
+                }
+            }
+        }
+
         public void Start()
         {
             // if already started or already stopped we can't be started again
             Debug.Assert(_collectThread == null && !_cts.IsCancellationRequested);
-            Debug.Assert(_collectionPeriod.TotalSeconds >= MinCollectionTimeSecs);
+            Debug.Assert(CollectionPeriod.TotalSeconds >= MinCollectionTimeSecs);
 
             // This explicitly uses a Thread and not a Task so that metrics still work
             // even when an app is experiencing thread-pool starvation. Although we
@@ -148,14 +160,28 @@ public void Start()
             _initialInstrumentEnumerationComplete();
         }
 
+        public void Update()
+        {
+            // Creating (and destroying) a MeterListener to leverage the existing
+            // mechanisms for enumerating and publishing instruments.
+            using (MeterListener tempListener = new MeterListener())
+            {
+                tempListener.InstrumentPublished += PublishedInstrument;
+                tempListener.MeasurementsCompleted += CompletedMeasurements;
+                tempListener.Start();
+            }
+
+            _initialInstrumentEnumerationComplete();
+        }
+
         private void CollectWorker(CancellationToken cancelToken)
         {
             try
             {
                 double collectionIntervalSecs = -1;
                 lock (this)
                 {
-                    collectionIntervalSecs = _collectionPeriod.TotalSeconds;
+                    collectionIntervalSecs = CollectionPeriod.TotalSeconds;
                 }
                 Debug.Assert(collectionIntervalSecs >= MinCollectionTimeSecs);
 
@@ -340,12 +366,12 @@ private void RemoveInstrumentState(Instrument instrument)
 
         private bool CheckTimeSeriesAllowed()
         {
-            if (_currentTimeSeries < _maxTimeSeries)
+            if (_currentTimeSeries < MaxTimeSeries)
             {
                 _currentTimeSeries++;
                 return true;
             }
-            else if (_currentTimeSeries == _maxTimeSeries)
+            else if (_currentTimeSeries == MaxTimeSeries)
             {
                 _currentTimeSeries++;
                 _timeSeriesLimitReached();
@@ -359,12 +385,12 @@ private bool CheckTimeSeriesAllowed()
 
         private bool CheckHistogramAllowed()
         {
-            if (_currentHistograms < _maxHistograms)
+            if (_currentHistograms < MaxHistograms)
             {
                 _currentHistograms++;
                 return true;
             }
-            else if (_currentHistograms == _maxHistograms)
+            else if (_currentHistograms == MaxHistograms)
             {
                 _currentHistograms++;
                 _histogramLimitReached();