Limit number of events stored in TestEventListener (Azure#22263)

* Limit number of events stored in TestEventListener

* Throw exception when events are dropped
Increase default max event count to 1000.

* Dispose the event listener in AzureIdentityEventSourceTests

* Add comments on TestEventListener ctor

* Dispose TestEventListener in a timely manner

* Use method local TestEventListener in Search

Author: Mohit-Chakraborty

sdk/core/Azure.Core.TestFramework/src/RecordedTestBase.cs

@@ -99,7 +99,7 @@ private string GetSessionFilePath()
         }
 
         /// <summary>
-        /// Add a static TestEventListener which will redirect SDK logging
+        /// Add a static <see cref="Diagnostics.AzureEventSourceListener"/> which will redirect SDK logging
         /// to Console.Out for easy debugging.
         /// </summary>
         private static TestLogger Logger { get; set; }

sdk/core/Azure.Core.TestFramework/src/TestEventListener.cs

@@ -14,6 +14,8 @@ public class TestEventListener : EventListener
     {
         private volatile bool _disposed;
         private readonly ConcurrentQueue<EventWrittenEventArgs> _events = new ConcurrentQueue<EventWrittenEventArgs>();
+        private uint _maxEventCount;
+        private const uint DefaultMaxEventCount = 1000;
 
         public IEnumerable<EventWrittenEventArgs> EventData => _events;
 
@@ -27,12 +29,33 @@ protected override void OnEventWritten(EventWrittenEventArgs eventData)
 
             if (!_disposed)
             {
+                if (_events.Count >= _maxEventCount)
+                {
+                    throw new Exception($"Number of events has exceeded {_maxEventCount}. Create {typeof(TestEventListener)} with a larger 'maxEventCount'.");
+                }
+
                 // Make sure we can format the event
                 EventSourceEventFormatting.Format(eventData);
                 _events.Enqueue(eventData);
             }
         }
 
+        /// <summary>
+        /// Creates an instance of <see cref="TestEventListener"/>.
+        /// </summary>
+        public TestEventListener() : this(DefaultMaxEventCount)
+        { }
+
+        /// <summary>
+        /// Creates an instance of <see cref="TestEventListener"/>.
+        /// </summary>
+        /// <param name="maxEventCount">Maximum number of events that the listener can store in <see cref="EventData"/>.
+        /// <para>If the number of events exceeds the value, an <see cref="Exception"/> is thrown.</para></param>
+        public TestEventListener(uint maxEventCount)
+        {
+            _maxEventCount = maxEventCount;
+        }
+
         public EventWrittenEventArgs SingleEventById(int id, Func<EventWrittenEventArgs, bool> filter = null)
         {
             return EventsById(id).Single(filter ?? (_ => true));

sdk/core/Azure.Core/tests/RetryPolicyTestBase.cs

@@ -265,7 +265,7 @@ public async Task MsHeadersArePreferredOverRetryAfter(string headerName)
         public async Task RetryingEmitsEventSourceEvent()
         {
             var responseClassifier = new MockResponseClassifier(retriableCodes: new[] { 500 });
-            var listener = new TestEventListener();
+            using var listener = new TestEventListener();
             listener.EnableEvents(AzureCoreEventSource.Singleton, EventLevel.Informational);
 
             (HttpPipelinePolicy policy, AsyncGate<TimeSpan, object> gate) = CreateRetryPolicy(maxRetries: 2);

sdk/identity/Azure.Identity/tests/AzureIdentityEventSourceTests.cs

@@ -35,6 +35,12 @@ public void Setup()
             _listener.EnableEvents(AzureIdentityEventSource.Singleton, EventLevel.Verbose);
         }
 
+        [TearDown]
+        public void TearDown()
+        {
+            _listener.Dispose();
+        }
+
         [Test]
         public void MatchesNameAndGuid()
         {

sdk/search/Azure.Search.Documents/tests/Batching/BatchingTests.cs

@@ -22,26 +22,11 @@ namespace Azure.Search.Documents.Tests
     [NonParallelizable]
     public class BatchingTests : SearchTestBase
     {
-        private TestEventListener _listener;
-
         public BatchingTests(bool async, SearchClientOptions.ServiceVersion serviceVersion)
             : base(async, serviceVersion, null /* RecordedTestMode.Record /* to re-record */)
         {
         }
 
-        [SetUp]
-        public void Setup()
-        {
-            _listener = new TestEventListener();
-            _listener.EnableEvents(AzureSearchDocumentsEventSource.Instance, EventLevel.Verbose);
-        }
-
-        [TearDown]
-        public void TearDown()
-        {
-            _listener.Dispose();
-        }
-
         #region Utilities
         private const int BatchSize = SearchIndexingBufferedSenderOptions<object>.DefaultInitialBatchActionCount;
         private readonly TimeSpan EventDelay = TimeSpan.FromMilliseconds(250);
@@ -1067,10 +1052,13 @@ public async Task Behavior_Split()
 
             client.SplitNextBatch = true;
 
+            using var listener = new TestEventListener();
+            listener.EnableEvents(AzureSearchDocumentsEventSource.Instance, EventLevel.Verbose);
+
             await indexer.UploadDocumentsAsync(data);
             await indexer.FlushAsync();
 
-            List<EventWrittenEventArgs> eventData = _listener.EventData.ToList();
+            List<EventWrittenEventArgs> eventData = listener.EventData.ToList();
 
             Assert.AreEqual(10, eventData.Count);
             Assert.AreEqual("PendingQueueResized", eventData[0].EventName);         // 1. All events are pushed into the pending queue.