Return Global and Http Request buffering options

src/Libraries/Microsoft.Extensions.Telemetry/Logging/Buffering/GlobalBuffer.cs

@@ -16,12 +16,12 @@ namespace Microsoft.Extensions.Diagnostics.Logging.Buffering;
 
 internal class GlobalBuffer : BackgroundService, ILoggingBuffer
 {
-    private readonly BufferingOptions _options;
+    private readonly GlobalBufferingOptions _options;
     private readonly ConcurrentDictionary<IBufferedLogger, ConcurrentQueue<GlobalBufferedLogRecord>> _buffers;
     private readonly TimeProvider _timeProvider = TimeProvider.System;
     private DateTimeOffset _lastFlushTimestamp;
 
-    public GlobalBuffer(IOptions<BufferingOptions> options)
+    public GlobalBuffer(IOptions<GlobalBufferingOptions> options)
     {
         _options = options.Value;
         _lastFlushTimestamp = _timeProvider.GetUtcNow();

src/Libraries/Microsoft.Extensions.Telemetry/Logging/Buffering/GlobalBufferingLoggerBuilderExtensions.cs

@@ -23,7 +23,7 @@ public static class GlobalBufferingLoggerBuilderExtensions
     public static ILoggingBuilder AddGlobalBuffering(
         this ILoggingBuilder builder,
         Func<string?, EventId?, LogLevel?, bool> filter,
-        Action<BufferingOptions>? options = null)
+        Action<GlobalBufferingOptions>? options = null)
     {
         _ = Throw.IfNull(builder);
 
@@ -51,17 +51,17 @@ public static ILoggingBuilder AddGlobalBufferProvider(this ILoggingBuilder build
     /// </summary>
     /// <param name="builder">The <see cref="ILoggingBuilder"/> to add the buffer to.</param>
     /// <param name="filter">The filter to be used to decide what to buffer.</param>
-    /// <param name="configureOptions">The delegate to configure <see cref="BufferingOptions"/>.</param>
+    /// <param name="configureOptions">The delegate to configure <see cref="GlobalBufferingOptions"/>.</param>
     /// <returns>The <see cref="ILoggingBuilder"/> so that additional calls can be chained.</returns>
     public static ILoggingBuilder ConfigureBuffering(
         this ILoggingBuilder builder,
         Func<string?, EventId?, LogLevel?, bool> filter,
-        Action<BufferingOptions>? configureOptions = null)
+        Action<GlobalBufferingOptions>? configureOptions = null)
     {
         _ = Throw.IfNull(builder);
 
-        _ = builder.Services.Configure(configureOptions ?? new Action<BufferingOptions>((_) => { }));
-        _ = builder.Services.Configure<BufferingOptions>(opts => opts.AddFilter(filter));
+        _ = builder.Services.Configure(configureOptions ?? new Action<GlobalBufferingOptions>((_) => { }));
+        _ = builder.Services.Configure<GlobalBufferingOptions>(opts => opts.AddFilter(filter));
 
         return builder;
     }
@@ -70,7 +70,7 @@ public static ILoggingBuilder ConfigureBuffering(
     /// Adds a log buffer to the factory.
     /// </summary>
     public static void AddFilter(
-        this BufferingOptions options,
+        this GlobalBufferingOptions options,
         Func<string?, EventId?, LogLevel?, bool> filter)
     {
         _ = Throw.IfNull(options);

src/Libraries/Microsoft.Extensions.Telemetry/Logging/Buffering/BufferingOptions.cs → src/Libraries/Microsoft.Extensions.Telemetry/Logging/Buffering/GlobalBufferingOptions.cs

@@ -9,7 +9,7 @@ namespace Microsoft.Extensions.Diagnostics.Logging.Buffering;
 /// <summary>
 /// The options for LoggerBuffer.
 /// </summary>
-public class BufferingOptions
+public class GlobalBufferingOptions
 {
     /// <summary>
     /// Gets or sets the time to suspend the buffer after flushing.

src/Libraries/Microsoft.Extensions.Telemetry/Logging/Buffering/HttpRequestBuffer.cs

@@ -44,12 +44,16 @@ public bool TryEnqueue(
         // probably don't need to limit buffer capacity?
         // becase buffer is disposed when the respective HttpContext is disposed
         // don't expect it to grow so much to cause a problem?
+        if (queue.Count >= _options.PerRequestCapacity)
+        {
+            _ = queue.TryDequeue(out HttpRequestBufferedLogRecord? _);
+        }
 
         // having said that, I question the usefullness of the HTTP buffering.
         // If I have 1000 RPS each with a buffer which is auto-disposed,
         // then something bad happens and 900 requests out of 1000 failed,
         // their HttpContext were disposed, as well as buffers,
-        // so at this point logs are lost and it is too late to call the Flusth() method
+        // so at this point logs are lost and it is too late to call the Flush() method
 
         queue.Enqueue(record);
 

src/Libraries/Microsoft.Extensions.Telemetry/Logging/Buffering/HttpRequestBufferingLoggerBuilderExtensions.cs

@@ -23,13 +23,13 @@ public static class HttpRequestBufferingLoggerBuilderExtensions
     public static ILoggingBuilder AddHttpRequestBuffering(
         this ILoggingBuilder builder,
         Func<string?, EventId?, LogLevel?, bool> filter,
-        Action<BufferingOptions>? options = null)
+        Action<HttpRequestBufferingOptions>? options = null)
     {
         _ = Throw.IfNull(builder);
 
         return builder
             .AddHttpRequestBufferProvider()
-            .ConfigureBuffering(filter, options);
+            .ConfigureHttpRequestBuffering(filter, options);
     }
 
     /// <summary>
@@ -45,4 +45,45 @@ public static ILoggingBuilder AddHttpRequestBufferProvider(this ILoggingBuilder
 
         return builder;
     }
+
+    /// <summary>
+    /// Adds a log buffer to the factory.
+    /// </summary>
+    /// <param name="builder">The <see cref="ILoggingBuilder"/> to add the buffer to.</param>
+    /// <param name="filter">The filter to be used to decide what to buffer.</param>
+    /// <param name="configureOptions">The delegate to configure <see cref="HttpRequestBufferingOptions"/>.</param>
+    /// <returns>The <see cref="ILoggingBuilder"/> so that additional calls can be chained.</returns>
+    public static ILoggingBuilder ConfigureHttpRequestBuffering(
+        this ILoggingBuilder builder,
+        Func<string?, EventId?, LogLevel?, bool> filter,
+        Action<HttpRequestBufferingOptions>? configureOptions = null)
+    {
+        _ = Throw.IfNull(builder);
+
+        _ = builder.Services.Configure(configureOptions ?? new Action<HttpRequestBufferingOptions>((_) => { }));
+        _ = builder.Services.Configure<HttpRequestBufferingOptions>(opts => opts.AddHttpRequestBufferingFilter(filter));
+        _ = builder.Services
+            .AddOptions<GlobalBufferingOptions>()
+            .Configure<HttpRequestBufferingOptions>((globalOpts, requestOpts) =>
+            {
+                globalOpts.Capacity = requestOpts.GlobalCapacity;
+                globalOpts.Filter = requestOpts.Filter;
+                globalOpts.SuspendAfterFlushDuration = requestOpts.SuspendAfterFlushDuration;
+            });
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds a log buffer to the factory.
+    /// </summary>
+    public static void AddHttpRequestBufferingFilter(
+        this HttpRequestBufferingOptions options,
+        Func<string?, EventId?, LogLevel?, bool> filter)
+    {
+        _ = Throw.IfNull(options);
+        _ = Throw.IfNull(filter);
+
+        options.Filter = filter;
+    }
 }

src/Libraries/Microsoft.Extensions.Telemetry/Logging/Buffering/HttpRequestBufferingOptions.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Extensions.Diagnostics.Logging.Buffering;
+
+/// <summary>
+/// The options for LoggerBuffer.
+/// </summary>
+public class HttpRequestBufferingOptions
+{
+    /// <summary>
+    /// Gets or sets the time to suspend the buffer after flushing.
+    /// </summary>
+    /// <remarks>
+    /// Use this to temporarily suspend buffering after a flush, e.g. in case of an incident you may want all logs to be emitted immediately,
+    /// so the buffering will be suspended for the <see paramref="SuspendAfterFlushDuration"/> time.
+    /// </remarks>
+    public TimeSpan SuspendAfterFlushDuration { get; set; } = TimeSpan.FromSeconds(30);
+
+    /// <summary>
+    /// Gets or sets the size of the buffer for a request.
+    /// </summary>
+    public int PerRequestCapacity { get; set; } = 1_000;
+
+    /// <summary>
+    /// Gets or sets the size of the buffer for a request.
+    /// </summary>
+    public int GlobalCapacity { get; set; } = 1_000_000;
+
+    /// <summary>
+    /// Gets or sets the filter delegate to determine what to buffer.
+    /// </summary>
+    internal Func<string?, EventId?, LogLevel?, bool> Filter { get; set; } = (_, _, _) => false;
+}