test: Batch Processor for Logs

src/Sentry/Internal/BatchBuffer.cs

@@ -7,6 +7,8 @@ internal sealed class BatchBuffer<T>
 
     public BatchBuffer(int capacity)
     {
+        ThrowIfNegativeOrZero(capacity, nameof(capacity));
+
         _array = new T[capacity];
         _count = 0;
     }
@@ -18,11 +20,10 @@ public BatchBuffer(int capacity)
 
     internal bool TryAdd(T item)
     {
-        var count = Interlocked.Increment(ref _count);
-
-        if (count <= _array.Length)
+        if (_count < _array.Length)
         {
-            _array[count - 1] = item;
+            _array[_count] = item;
+            _count++;
             return true;
         }
 
@@ -59,4 +60,17 @@ internal T[] ToArrayAndClear()
         Clear();
         return array;
     }
+
+    private static void ThrowIfNegativeOrZero(int capacity, string paramName)
+    {
+        if (capacity <= 0)
+        {
+            ThrowNegativeOrZero(capacity, paramName);
+        }
+    }
+
+    private static void ThrowNegativeOrZero(int capacity, string paramName)
+    {
+        throw new ArgumentOutOfRangeException(paramName, capacity, "Argument must neither be negative nor zero.");
+    }
 }

src/Sentry/Internal/BatchProcessor.cs

@@ -1,4 +1,5 @@
 using System.Timers;
+using Sentry.Protocol;
 using Sentry.Protocol.Envelopes;
 
 #if NET9_0_OR_GREATER
@@ -12,21 +13,22 @@ namespace Sentry.Internal;
 internal sealed class BatchProcessor : IDisposable
 {
     private readonly IHub _hub;
-    private readonly System.Timers.Timer _timer;
+    private readonly BatchProcessorTimer _timer;
     private readonly BatchBuffer<SentryLog> _logs;
     private readonly Lock _lock;
 
     private DateTime _lastFlush = DateTime.MinValue;
 
     public BatchProcessor(IHub hub, int batchCount, TimeSpan batchInterval)
+        : this(hub, batchCount, new TimersBatchProcessorTimer(batchInterval))
+    {
+    }
+
+    public BatchProcessor(IHub hub, int batchCount, BatchProcessorTimer timer)
     {
         _hub = hub;
 
-        _timer = new System.Timers.Timer(batchInterval.TotalMilliseconds)
-        {
-            AutoReset = false,
-            Enabled = false,
-        };
+        _timer = timer;
         _timer.Elapsed += IntervalElapsed;
 
         _logs = new BatchBuffer<SentryLog>(batchCount);
@@ -63,7 +65,7 @@ private void Flush()
         _lastFlush = DateTime.UtcNow;
 
         var logs = _logs.ToArrayAndClear();
-        _ = _hub.CaptureEnvelope(Envelope.FromLogs(logs));
+        _ = _hub.CaptureEnvelope(Envelope.FromLog(new StructuredLog(logs)));
     }
 
     private void IntervalElapsed(object? sender, ElapsedEventArgs e)

src/Sentry/Internal/BatchProcessorTimer.cs

@@ -0,0 +1,61 @@
+using System.Timers;
+
+namespace Sentry.Internal;
+
+internal abstract class BatchProcessorTimer : IDisposable
+{
+    protected BatchProcessorTimer()
+    {
+    }
+
+    public abstract bool Enabled { get; set; }
+
+    public abstract event EventHandler<ElapsedEventArgs> Elapsed;
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+    }
+}
+
+internal sealed class TimersBatchProcessorTimer : BatchProcessorTimer
+{
+    private readonly System.Timers.Timer _timer;
+
+    public TimersBatchProcessorTimer(TimeSpan interval)
+    {
+        _timer = new System.Timers.Timer(interval.TotalMilliseconds)
+        {
+            AutoReset = false,
+            Enabled = false,
+        };
+        _timer.Elapsed += OnElapsed;
+    }
+
+    public override bool Enabled
+    {
+        get => _timer.Enabled;
+        set => _timer.Enabled = value;
+    }
+
+    public override event EventHandler<ElapsedEventArgs>? Elapsed;
+
+    private void OnElapsed(object? sender, ElapsedEventArgs e)
+    {
+        Elapsed?.Invoke(sender, e);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _timer.Elapsed -= OnElapsed;
+            _timer.Dispose();
+        }
+    }
+}

src/Sentry/Protocol/Envelopes/Envelope.cs

@@ -446,13 +446,13 @@ internal static Envelope FromClientReport(ClientReport clientReport)
     }
 
     [Experimental(DiagnosticId.ExperimentalFeature)]
-    internal static Envelope FromLogs(SentryLog[] logs)
+    internal static Envelope FromLog(StructuredLog log)
     {
         var header = DefaultHeader;
 
         var items = new[]
         {
-            EnvelopeItem.FromLogs(logs),
+            EnvelopeItem.FromLog(log),
         };
 
         return new Envelope(header, items);

src/Sentry/Protocol/Envelopes/EnvelopeItem.cs

@@ -372,16 +372,15 @@ internal static EnvelopeItem FromClientReport(ClientReport report)
     }
 
     [Experimental(Infrastructure.DiagnosticId.ExperimentalFeature)]
-    internal static EnvelopeItem FromLogs(SentryLog[] logs)
+    internal static EnvelopeItem FromLog(StructuredLog log)
     {
         var header = new Dictionary<string, object?>(3, StringComparer.Ordinal)
         {
             [TypeKey] = TypeValueLog,
-            ["item_count"] = logs.Length,
+            ["item_count"] = log.Length,
             ["content_type"] = "application/vnd.sentry.items.log+json",
         };
 
-        var log = new StructuredLog(logs);
         return new EnvelopeItem(header, new JsonSerializable(log));
     }
 

src/Sentry/Protocol/StructuredLog.cs

@@ -6,11 +6,17 @@ internal sealed class StructuredLog : ISentryJsonSerializable
 {
     private readonly SentryLog[] _items;
 
+    public StructuredLog(SentryLog log)
+    {
+        _items = [log];
+    }
+
     public StructuredLog(SentryLog[] logs)
     {
         _items = logs;
     }
 
+    public int Length => _items.Length;
     public ReadOnlySpan<SentryLog> Items => _items;
 
     public void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)

test/Sentry.Tests/Internals/BatchBufferTests.cs

@@ -0,0 +1,175 @@
+namespace Sentry.Tests.Internals;
+
+public class BatchBufferTests
+{
+    [Fact]
+    public void Ctor_CapacityIsNegative_Throws()
+    {
+        var ctor = () => new BatchBuffer<string>(-1);
+
+        Assert.Throws<ArgumentOutOfRangeException>("capacity", ctor);
+    }
+
+    [Fact]
+    public void Ctor_CapacityIsZero_Throws()
+    {
+        var ctor = () => new BatchBuffer<string>(0);
+
+        Assert.Throws<ArgumentOutOfRangeException>("capacity", ctor);
+    }
+
+    [Fact]
+    public void TryAdd_CapacityOne_CanAddOnce()
+    {
+        var buffer = new BatchBuffer<string>(1);
+        AssertProperties(buffer, 0, 1, true, false);
+
+        buffer.TryAdd("one").Should().BeTrue();
+        AssertProperties(buffer, 1, 1, false, true);
+
+        buffer.TryAdd("two").Should().BeFalse();
+        AssertProperties(buffer, 1, 1, false, true);
+    }
+
+    [Fact]
+    public void TryAdd_CapacityTwo_CanAddTwice()
+    {
+        var buffer = new BatchBuffer<string>(2);
+        AssertProperties(buffer, 0, 2, true, false);
+
+        buffer.TryAdd("one").Should().BeTrue();
+        AssertProperties(buffer, 1, 2, false, false);
+
+        buffer.TryAdd("two").Should().BeTrue();
+        AssertProperties(buffer, 2, 2, false, true);
+
+        buffer.TryAdd("three").Should().BeFalse();
+        AssertProperties(buffer, 2, 2, false, true);
+    }
+
+    [Fact]
+    public void ToArray_IsEmpty_EmptyArray()
+    {
+        var buffer = new BatchBuffer<string>(3);
+
+        var array = buffer.ToArray();
+
+        Assert.Empty(array);
+        AssertProperties(buffer, 0, 3, true, false);
+    }
+
+    [Fact]
+    public void ToArray_IsNotEmptyNorFull_PartialArray()
+    {
+        var buffer = new BatchBuffer<string>(3);
+        buffer.TryAdd("one").Should().BeTrue();
+        buffer.TryAdd("two").Should().BeTrue();
+
+        var array = buffer.ToArray();
+
+        Assert.Collection(array,
+            item => Assert.Equal("one", item),
+            item => Assert.Equal("two", item));
+        AssertProperties(buffer, 2, 3, false, false);
+    }
+
+    [Fact]
+    public void ToArray_IsFull_FullArray()
+    {
+        var buffer = new BatchBuffer<string>(3);
+        buffer.TryAdd("one").Should().BeTrue();
+        buffer.TryAdd("two").Should().BeTrue();
+        buffer.TryAdd("three").Should().BeTrue();
+
+        var array = buffer.ToArray();
+
+        Assert.Collection(array,
+            item => Assert.Equal("one", item),
+            item => Assert.Equal("two", item),
+            item => Assert.Equal("three", item));
+        AssertProperties(buffer, 3, 3, false, true);
+    }
+
+    [Fact]
+    public void Clear_IsEmpty_NoOp()
+    {
+        var buffer = new BatchBuffer<string>(2);
+
+        AssertProperties(buffer, 0, 2, true, false);
+        buffer.Clear();
+        AssertProperties(buffer, 0, 2, true, false);
+    }
+
+    [Fact]
+    public void Clear_IsNotEmptyNorFull_ClearArray()
+    {
+        var buffer = new BatchBuffer<string>(2);
+        buffer.TryAdd("one").Should().BeTrue();
+
+        AssertProperties(buffer, 1, 2, false, false);
+        buffer.Clear();
+        AssertProperties(buffer, 0, 2, true, false);
+    }
+
+    [Fact]
+    public void Clear_IsFull_ClearArray()
+    {
+        var buffer = new BatchBuffer<string>(2);
+        buffer.TryAdd("one").Should().BeTrue();
+        buffer.TryAdd("two").Should().BeTrue();
+
+        AssertProperties(buffer, 2, 2, false, true);
+        buffer.Clear();
+        AssertProperties(buffer, 0, 2, true, false);
+    }
+
+    [Fact]
+    public void ToArrayAndClear_IsEmpty_EmptyArray()
+    {
+        var buffer = new BatchBuffer<string>(2);
+
+        AssertProperties(buffer, 0, 2, true, false);
+        var array = buffer.ToArrayAndClear();
+        AssertProperties(buffer, 0, 2, true, false);
+        Assert.Empty(array);
+    }
+
+    [Fact]
+    public void ToArrayAndClear_IsNotEmptyNorFull_PartialArray()
+    {
+        var buffer = new BatchBuffer<string>(2);
+        buffer.TryAdd("one").Should().BeTrue();
+
+        AssertProperties(buffer, 1, 2, false, false);
+        var array = buffer.ToArrayAndClear();
+        AssertProperties(buffer, 0, 2, true, false);
+        Assert.Collection(array,
+            item => Assert.Equal("one", item));
+    }
+
+    [Fact]
+    public void ToArrayAndClear_IsFull_FullArray()
+    {
+        var buffer = new BatchBuffer<string>(2);
+        buffer.TryAdd("one").Should().BeTrue();
+        buffer.TryAdd("two").Should().BeTrue();
+
+        AssertProperties(buffer, 2, 2, false, true);
+        var array = buffer.ToArrayAndClear();
+        AssertProperties(buffer, 0, 2, true, false);
+        Assert.Collection(array,
+            item => Assert.Equal("one", item),
+            item => Assert.Equal("two", item));
+    }
+
+    private static void AssertProperties<T>(BatchBuffer<T> buffer, int count, int capacity, bool empty, bool full)
+    {
+        using (new AssertionScope())
+        {
+            buffer.Count.Should().Be(count);
+            buffer.Capacity.Should().Be(capacity);
+            buffer.IsEmpty.Should().Be(empty);
+            buffer.IsFull.Should().Be(full);
+        }
+    }
+}