feat: add Batch Processor for Logs

src/Sentry/Internal/BatchBuffer.cs

@@ -0,0 +1,62 @@
+namespace Sentry.Internal;
+
+internal sealed class BatchBuffer<T>
+{
+    private readonly T[] _array;
+    private int _count;
+
+    public BatchBuffer(int capacity)
+    {
+        _array = new T[capacity];
+        _count = 0;
+    }
+
+    internal int Count => _count;
+    internal int Capacity => _array.Length;
+    internal bool IsEmpty => _count == 0 && _array.Length != 0;
+    internal bool IsFull => _count == _array.Length;
+
+    internal bool TryAdd(T item)
+    {
+        var count = Interlocked.Increment(ref _count);
+
+        if (count <= _array.Length)
+        {
+            _array[count - 1] = item;
+            return true;
+        }
+
+        return false;
+    }
+
+    internal T[] ToArray()
+    {
+        if (_count == 0)
+        {
+            return Array.Empty<T>();
+        }
+
+        var array = new T[_count];
+        Array.Copy(_array, array, _count);
+        return array;
+    }
+
+    internal void Clear()
+    {
+        if (_count == 0)
+        {
+            return;
+        }
+
+        var count = _count;
+        _count = 0;
+        Array.Clear(_array, 0, count);
+    }
+
+    internal T[] ToArrayAndClear()
+    {
+        var array = ToArray();
+        Clear();
+        return array;
+    }
+}

src/Sentry/Internal/BatchProcessor.cs

@@ -0,0 +1,88 @@
+using System.Timers;
+using Sentry.Protocol.Envelopes;
+
+#if NET9_0_OR_GREATER
+using Lock = System.Threading.Lock;
+#else
+using Lock = object;
+#endif
+
+namespace Sentry.Internal;
+
+internal sealed class BatchProcessor : IDisposable
+{
+    private readonly IHub _hub;
+    private readonly System.Timers.Timer _timer;
+    private readonly BatchBuffer<SentryLog> _logs;
+    private readonly Lock _lock;
+
+    private DateTime _lastFlush = DateTime.MinValue;
+
+    public BatchProcessor(IHub hub, int batchCount, TimeSpan batchInterval)
+    {
+        _hub = hub;
+
+        _timer = new System.Timers.Timer(batchInterval.TotalMilliseconds)
+        {
+            AutoReset = false,
+            Enabled = false,
+        };
+        _timer.Elapsed += IntervalElapsed;
+
+        _logs = new BatchBuffer<SentryLog>(batchCount);
+        _lock = new Lock();
+    }
+
+    internal void Enqueue(SentryLog log)
+    {
+        lock (_lock)
+        {
+            EnqueueCore(log);
+        }
+    }
+
+    private void EnqueueCore(SentryLog log)
+    {
+        var empty = _logs.IsEmpty;
+        var added = _logs.TryAdd(log);
+        Debug.Assert(added, $"Since we currently have no lock-free scenario, it's unexpected to exceed the {nameof(BatchBuffer<SentryLog>)}'s capacity.");
+
+        if (empty && !_logs.IsFull)
+        {
+            _timer.Enabled = true;
+        }
+        else if (_logs.IsFull)
+        {
+            _timer.Enabled = false;
+            Flush();
+        }
+    }
+
+    private void Flush()
+    {
+        _lastFlush = DateTime.UtcNow;
+
+        var logs = _logs.ToArrayAndClear();
+        _ = _hub.CaptureEnvelope(Envelope.FromLogs(logs));
+    }
+
+    private void IntervalElapsed(object? sender, ElapsedEventArgs e)
+    {
+        _timer.Enabled = false;
+
+        lock (_lock)
+        {
+            if (!_logs.IsEmpty && e.SignalTime > _lastFlush)
+            {
+                Flush();
+            }
+        }
+    }
+
+    public void Dispose()
+    {
+        _timer.Enabled = false;
+        _timer.Elapsed -= IntervalElapsed;
+        _timer.Dispose();
+    }
+}

src/Sentry/Internal/DefaultSentryStructuredLogger.cs

@@ -1,6 +1,5 @@
 using Sentry.Extensibility;
 using Sentry.Infrastructure;
-using Sentry.Protocol.Envelopes;
 
 namespace Sentry.Internal;
 
@@ -10,13 +9,33 @@ internal sealed class DefaultSentryStructuredLogger : SentryStructuredLogger
     private readonly SentryOptions _options;
     private readonly ISystemClock _clock;
 
+    private readonly BatchProcessor _batchProcessor;
+
     internal DefaultSentryStructuredLogger(IHub hub, SentryOptions options, ISystemClock clock)
     {
         Debug.Assert(options is { Experimental.EnableLogs: true });
 
         _hub = hub;
         _options = options;
         _clock = clock;
+
+        _batchProcessor = new BatchProcessor(hub, ClampBatchCount(options.Experimental.InternalBatchSize), ClampBatchInterval(options.Experimental.InternalBatchTimeout));
+    }
+
+    private static int ClampBatchCount(int batchCount)
+    {
+        return batchCount <= 0
+            ? 1
+            : batchCount > 1_000_000
+                ? 1_000_000
+                : batchCount;
+    }
+
+    private static TimeSpan ClampBatchInterval(TimeSpan batchInterval)
+    {
+        return batchInterval.TotalMilliseconds is <= 0 or > int.MaxValue
+            ? TimeSpan.FromMilliseconds(int.MaxValue)
+            : batchInterval;
     }
 
     private protected override void CaptureLog(SentryLogLevel level, string template, object[]? parameters, Action<SentryLog>? configureLog)
@@ -71,9 +90,17 @@ private protected override void CaptureLog(SentryLogLevel level, string template
 
         if (configuredLog is not null)
         {
-            //TODO: enqueue in Batch-Processor / Background-Worker
-            // see https://github.com/getsentry/sentry-dotnet/issues/4132
-            _ = _hub.CaptureEnvelope(Envelope.FromLog(configuredLog));
+            _batchProcessor.Enqueue(configuredLog);
         }
     }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _batchProcessor.Dispose();
+        }
+
+        base.Dispose(disposing);
+    }
 }

src/Sentry/Internal/Hub.cs

@@ -778,6 +778,8 @@ public void Dispose()
         _memoryMonitor?.Dispose();
 #endif
 
+        Logger.Dispose();
+
         try
         {
             CurrentClient.FlushAsync(_options.ShutdownTimeout).ConfigureAwait(false).GetAwaiter().GetResult();

src/Sentry/Protocol/Envelopes/Envelope.cs

@@ -445,17 +445,14 @@ internal static Envelope FromClientReport(ClientReport clientReport)
         return new Envelope(header, items);
     }
 
-    // TODO: This is temporary. We don't expect single log messages to become an envelope by themselves since batching is needed
     [Experimental(DiagnosticId.ExperimentalFeature)]
-    internal static Envelope FromLog(SentryLog log)
+    internal static Envelope FromLogs(SentryLog[] logs)
     {
-        //TODO: allow batching Sentry logs
-        //see https://github.com/getsentry/sentry-dotnet/issues/4132
         var header = DefaultHeader;
 
         var items = new[]
         {
-            EnvelopeItem.FromLog(log)
+            EnvelopeItem.FromLogs(logs),
         };
 
         return new Envelope(header, items);

src/Sentry/Protocol/Envelopes/EnvelopeItem.cs

@@ -372,17 +372,16 @@ internal static EnvelopeItem FromClientReport(ClientReport report)
     }
 
     [Experimental(Infrastructure.DiagnosticId.ExperimentalFeature)]
-    internal static EnvelopeItem FromLog(SentryLog log)
+    internal static EnvelopeItem FromLogs(SentryLog[] logs)
     {
-        //TODO: allow batching Sentry logs
-        //see https://github.com/getsentry/sentry-dotnet/issues/4132
         var header = new Dictionary<string, object?>(3, StringComparer.Ordinal)
         {
             [TypeKey] = TypeValueLog,
-            ["item_count"] = 1,
+            ["item_count"] = logs.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

@@ -0,0 +1,29 @@
+using Sentry.Extensibility;
+
+namespace Sentry.Protocol;
+
+internal sealed class StructuredLog : ISentryJsonSerializable
+{
+    private readonly SentryLog[] _items;
+
+    public StructuredLog(SentryLog[] logs)
+    {
+        _items = logs;
+    }
+
+    public ReadOnlySpan<SentryLog> Items => _items;
+
+    public void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
+    {
+        writer.WriteStartObject();
+        writer.WriteStartArray("items");
+
+        foreach (var log in _items)
+        {
+            log.WriteTo(writer, logger);
+        }
+
+        writer.WriteEndArray();
+        writer.WriteEndObject();
+    }
+}

src/Sentry/SentryLog.cs

@@ -9,7 +9,7 @@ namespace Sentry;
 /// <para>This API is experimental and it may change in the future.</para>
 /// </summary>
 [Experimental(DiagnosticId.ExperimentalFeature)]
-public sealed class SentryLog : ISentryJsonSerializable
+public sealed class SentryLog
 {
     private readonly Dictionary<string, SentryAttribute> _attributes;
 
@@ -188,12 +188,9 @@ internal void SetDefaultAttributes(SentryOptions options, SdkVersion sdk)
         }
     }
 
-    /// <inheritdoc />
-    public void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
+    internal void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
     {
         writer.WriteStartObject();
-        writer.WriteStartArray("items");
-        writer.WriteStartObject();
 
         writer.WriteNumber("timestamp", Timestamp.ToUnixTimeSeconds());
 
@@ -241,10 +238,8 @@ public void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
             writer.WriteEndObject();
         }
 
-        writer.WriteEndObject();
+        writer.WriteEndObject(); // attributes
 
         writer.WriteEndObject();
-        writer.WriteEndArray();
-        writer.WriteEndObject();
     }
 }

src/Sentry/SentryOptions.cs

@@ -1897,5 +1897,22 @@ public void SetBeforeSendLog(Func<SentryLog, SentryLog?> beforeSendLog)
         {
             _beforeSendLog = beforeSendLog;
         }
+
+        /// <summary>
+        /// This API will be removed in the future.
+        /// </summary>
+        /// <remarks>
+        /// Threshold of items in the buffer when sending all items, regardless of <see cref="InternalBatchTimeout"/>.
+        /// </remarks>
+        public int InternalBatchSize { get; set; } = 100;
+
+        /// <summary>
+        /// This API will be removed in the future.
+        /// </summary>
+        /// <remarks>
+        /// Time after which all items in the buffer are sent, regardless of <see cref="InternalBatchSize"/>.
+        /// <para>Must not exceed 30 seconds.</para>
+        /// </remarks>
+        public TimeSpan InternalBatchTimeout { get; set; } = TimeSpan.FromSeconds(5);
     }
 }

src/Sentry/SentryStructuredLogger.cs

@@ -8,7 +8,7 @@ namespace Sentry;
 /// <para>This API is experimental and it may change in the future.</para>
 /// </summary>
 [Experimental(DiagnosticId.ExperimentalFeature)]
-public abstract class SentryStructuredLogger
+public abstract class SentryStructuredLogger : IDisposable
 {
     internal static SentryStructuredLogger Create(IHub hub, SentryOptions options, ISystemClock clock)
     {
@@ -100,4 +100,19 @@ public void LogFatal(string template, object[]? parameters = null, Action<Sentry
     {
         CaptureLog(SentryLogLevel.Fatal, template, parameters, configureLog);
     }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Override in inherited types to clean up managed and unmanaged resources.
+    /// </summary>
+    /// <param name="disposing">Invoked from <see cref="Dispose()"/> when <see langword="true"/>; Invoked from <c>Finalize</c> when <see langword="false"/>.</param>
+    protected virtual void Dispose(bool disposing)
+    {
+    }
 }