fix: BatchBuffer flushed on Shutdown/Dispose

benchmarks/Sentry.Benchmarks/BatchProcessorBenchmarks.cs

@@ -0,0 +1,48 @@
+using BenchmarkDotNet.Attributes;
+using NSubstitute;
+using Sentry.Extensibility;
+using Sentry.Internal;
+using Sentry.Testing;
+
+namespace Sentry.Benchmarks;
+
+public class BatchProcessorBenchmarks
+{
+    private BatchProcessor _batchProcessor;
+    private SentryLog _log;
+
+    [Params(10, 100)]
+    public int BatchCount { get; set; }
+
+    [Params(100, 200, 1_000)]
+    public int OperationsPerInvoke { get; set; }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var hub = DisabledHub.Instance;
+        var batchInterval = Timeout.InfiniteTimeSpan;
+        var clock = new MockClock();
+        var clientReportRecorder = Substitute.For<IClientReportRecorder>();
+        var diagnosticLogger = Substitute.For<IDiagnosticLogger>();
+        _batchProcessor = new BatchProcessor(hub, BatchCount, batchInterval, clock, clientReportRecorder, diagnosticLogger);
+
+        _log = new SentryLog(DateTimeOffset.Now, SentryId.Empty, SentryLogLevel.Trace, "message");
+    }
+
+    [Benchmark]
+    public void EnqueueAndFlush()
+    {
+        for (var i = 0; i < OperationsPerInvoke; i++)
+        {
+            _batchProcessor.Enqueue(_log);
+        }
+        _batchProcessor.Flush();
+    }
+
+    [GlobalCleanup]
+    public void Cleanup()
+    {
+        _batchProcessor.Dispose();
+    }
+}

src/Sentry/Internal/BatchBuffer.cs

@@ -10,7 +10,7 @@ namespace Sentry.Internal;
 /// Not all members are thread-safe.
 /// See individual members for notes on thread safety.
 /// </remarks>
-[DebuggerDisplay("Name = {Name}, Capacity = {Capacity}, IsEmpty = {IsEmpty}, IsFull = {IsFull}, IsAddInProgress = {IsAddInProgress}")]
+[DebuggerDisplay("Name = {Name}, Capacity = {Capacity}, IsEmpty = {IsEmpty}, IsFull = {IsFull}, AddCount = {AddCount}")]
 internal sealed class BatchBuffer<T> : IDisposable
 {
     private readonly T[] _array;
@@ -67,24 +67,50 @@ public BatchBuffer(int capacity, string? name = null)
     /// </remarks>
     internal bool IsFull => _additions >= _array.Length;
 
-    internal FlushScope EnterFlushScope()
+    /// <summary>
+    /// Number of <see cref="TryAdd"/> operations in progress.
+    /// </summary>
+    /// <remarks>
+    /// This property is used for debugging only.
+    /// </remarks>
+    private int AddCount => _addCounter.Count;
+
+    /// <summary>
+    /// Enters a <see cref="FlushScope"/> used to ensure that only a single flush operation is in progress.
+    /// </summary>
+    /// <returns>A <see cref="FlushScope"/> that must be disposed to exit.</returns>
+    /// <remarks>
+    /// This method is thread-safe.
+    /// </remarks>
+    internal FlushScope TryEnterFlushScope(out bool lockTaken)
     {
         if (_addLock.TryEnter())
         {
+            lockTaken = true;
             return new FlushScope(this);
         }
 
-        Debug.Fail("The FlushScope should not have been entered again, before the previously entered FlushScope has exited.");
+        lockTaken = false;
         return new FlushScope();
     }
 
+    /// <summary>
+    /// Exits the <see cref="FlushScope"/> through <see cref="FlushScope.Dispose"/>.
+    /// </summary>
+    /// <remarks>
+    /// This method is thread-safe.
+    /// </remarks>
     private void ExitFlushScope()
     {
         _addLock.Exit();
     }
 
-    internal bool IsAddInProgress => !_addCounter.IsSet;
-
+    /// <summary>
+    /// Blocks the current thread until all <see cref="TryAdd"/> operations have completed.
+    /// </summary>
+    /// <remarks>
+    /// This method is thread-safe.
+    /// </remarks>
     internal void WaitAddCompleted()
     {
         _addCounter.Wait();
@@ -177,6 +203,12 @@ private void Clear(int length)
         Array.Clear(_array, 0, length);
     }
 
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        _addCounter.Dispose();
+    }
+
     private static void ThrowIfLessThanTwo(int capacity, string paramName)
     {
         if (capacity < 2)
@@ -190,11 +222,6 @@ private static void ThrowLessThanTwo(int capacity, string paramName)
         throw new ArgumentOutOfRangeException(paramName, capacity, "Argument must be at least two.");
     }
 
-    public void Dispose()
-    {
-        _addCounter.Dispose();
-    }
-
     internal ref struct FlushScope : IDisposable
     {
         private BatchBuffer<T>? _lockObj;
@@ -204,6 +231,8 @@ internal FlushScope(BatchBuffer<T> lockObj)
             _lockObj = lockObj;
         }
 
+        internal bool IsEntered => _lockObj is not null;
+
         public void Dispose()
         {
             var lockObj = _lockObj;

src/Sentry/Internal/BatchProcessor.cs

@@ -64,6 +64,13 @@ internal void Enqueue(SentryLog log)
         }
     }
 
+    internal void Flush()
+    {
+        DisableTimer();
+        Flush(_buffer1);
+        Flush(_buffer2);
+    }
+
     private bool TryEnqueue(BatchBuffer<SentryLog> buffer, SentryLog log)
     {
         if (buffer.TryAdd(log, out var count))
@@ -75,7 +82,7 @@ private bool TryEnqueue(BatchBuffer<SentryLog> buffer, SentryLog log)
 
             if (count == buffer.Capacity) // is buffer full
             {
-                using var flushScope = buffer.EnterFlushScope();
+                using var flushScope = buffer.TryEnterFlushScope(out var lockTaken);
                 DisableTimer();
 
                 var currentActiveBuffer = _activeBuffer;
@@ -113,7 +120,9 @@ internal void OnIntervalElapsed(object? state)
         {
             var currentActiveBuffer = _activeBuffer;
 
-            if (!currentActiveBuffer.IsEmpty && _clock.GetUtcNow() > _lastFlush)
+            using var scope = currentActiveBuffer.TryEnterFlushScope(out var lockTaken);
+
+            if (lockTaken && !currentActiveBuffer.IsEmpty && _clock.GetUtcNow() > _lastFlush)
             {
                 _ = TrySwapBuffer(currentActiveBuffer);
                 Flush(currentActiveBuffer);

src/Sentry/Internal/DefaultSentryStructuredLogger.cs

@@ -38,6 +38,7 @@ private static TimeSpan ClampBatchInterval(TimeSpan batchInterval)
             : batchInterval;
     }
 
+    /// <inheritdoc />
     private protected override void CaptureLog(SentryLogLevel level, string template, object[]? parameters, Action<SentryLog>? configureLog)
     {
         var timestamp = _clock.GetUtcNow();
@@ -94,6 +95,13 @@ private protected override void CaptureLog(SentryLogLevel level, string template
         }
     }
 
+    /// <inheritdoc />
+    protected internal override void Flush()
+    {
+        _batchProcessor.Flush();
+    }
+
+    /// <inheritdoc />
     protected override void Dispose(bool disposing)
     {
         if (disposing)

src/Sentry/Internal/DisabledSentryStructuredLogger.cs

@@ -8,6 +8,7 @@ internal DisabledSentryStructuredLogger()
     {
     }
 
+    /// <inheritdoc />
     private protected override void CaptureLog(SentryLogLevel level, string template, object[]? parameters, Action<SentryLog>? configureLog)
     {
         // disabled

src/Sentry/Internal/Hub.cs

@@ -796,6 +796,7 @@ public void Dispose()
         _memoryMonitor?.Dispose();
 #endif
 
+        Logger.Flush();
         Logger.Dispose();
 
         try

src/Sentry/SentryStructuredLogger.cs

@@ -21,6 +21,14 @@ private protected SentryStructuredLogger()
     {
     }
 
+    /// <summary>
+    /// Buffers a <see href="https://develop.sentry.dev/sdk/telemetry/logs">Sentry Log</see> message
+    /// via the associated <see href="https://develop.sentry.dev/sdk/telemetry/spans/batch-processor">Batch Processor</see>.
+    /// </summary>
+    /// <param name="level">The severity level of the log.</param>
+    /// <param name="template">The parameterized template string.</param>
+    /// <param name="parameters">The parameters to the <paramref name="template"/> string.</param>
+    /// <param name="configureLog">A configuration callback. Will be removed in a future version.</param>
     private protected abstract void CaptureLog(SentryLogLevel level, string template, object[]? parameters, Action<SentryLog>? configureLog);
 
     /// <summary>
@@ -101,6 +109,14 @@ public void LogFatal(string template, object[]? parameters = null, Action<Sentry
         CaptureLog(SentryLogLevel.Fatal, template, parameters, configureLog);
     }
 
+    /// <summary>
+    /// When overridden in a derived <see langword="class"/>,
+    /// clears all buffers for this logger and causes any buffered logs to be sent by the underlying <see cref="ISentryClient"/>.
+    /// </summary>
+    protected internal virtual void Flush()
+    {
+    }
+
     /// <inheritdoc />
     public void Dispose()
     {

test/Sentry.Testing/InMemorySentryStructuredLogger.cs

@@ -6,6 +6,7 @@ public sealed class InMemorySentryStructuredLogger : SentryStructuredLogger
 {
     public List<LogEntry> Entries { get; } = new();
 
+    /// <inheritdoc />
     private protected override void CaptureLog(SentryLogLevel level, string template, object[]? parameters, Action<SentryLog>? configureLog)
     {
         Entries.Add(LogEntry.Create(level, template, parameters));

test/Sentry.Tests/Internals/BatchProcessorTests.cs

@@ -112,16 +112,17 @@ public void Enqueue_BothTimeoutAndSizeReached_CaptureEnvelopes()
         AssertEnvelopes(["one"], ["two", "three"]);
     }
 
-    [Fact(Skip = "TODO")]
+    [Fact]
     public async Task Enqueue_Concurrency_CaptureEnvelopes()
     {
         const int batchCount = 3;
+        const int maxDegreeOfParallelism = 5;
         const int logsPerTask = 100;
 
         using var processor = new BatchProcessor(_hub, batchCount, Timeout.InfiniteTimeSpan, _clock, _clientReportRecorder, _diagnosticLogger);
         using var sync = new ManualResetEvent(false);
 
-        var tasks = new Task[5];
+        var tasks = new Task[maxDegreeOfParallelism];
         for (var i = 0; i < tasks.Length; i++)
         {
             tasks[i] = Task.Factory.StartNew(static state =>
@@ -137,6 +138,7 @@ public async Task Enqueue_Concurrency_CaptureEnvelopes()
 
         sync.Set();
         await Task.WhenAll(tasks).WaitAsync(TimeSpan.FromSeconds(5));
+        processor.Flush();
         _capturedEnvelopes.CompleteAdding();
 
         var capturedLogs = _capturedEnvelopes