Introduce new extended logging model.

bench/Generators/Microsoft.Gen.Logging.PerformanceTests/MockLogger.cs → bench/Libraries/Microsoft.Extensions.Telemetry.PerformanceTests/BenchLogger.cs

@@ -4,19 +4,14 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.ObjectPool;
-using Microsoft.Extensions.Telemetry.Logging;
-using Microsoft.Shared.Pools;
 
-namespace Microsoft.Gen.Logging.Bench;
+namespace Microsoft.Extensions.Telemetry.Bench;
 
 /// <summary>
 /// A logger which captures the last log state logged to it.
 /// </summary>
-internal sealed class MockLogger : ILogger
+internal sealed class BenchLogger : ILogger
 {
-    private readonly ObjectPool<List<KeyValuePair<string, object?>>> _listPool = PoolFactory.CreateListPool<KeyValuePair<string, object?>>();
-
     private sealed class Disposable : IDisposable
     {
         public void Dispose()
@@ -35,48 +30,45 @@ public void Dispose()
         return new Disposable();
     }
 
-    public bool IsEnabled(LogLevel logLevel)
-    {
-        return Enabled;
-    }
-
-    public bool Enabled { get; set; }
+    public bool IsEnabled(LogLevel logLevel) => true;
 
     public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
     {
-        if (!IsEnabled(logLevel))
-        {
-            return;
-        }
-
         switch (state)
         {
-            case LogMethodHelper helper:
+            case IReadOnlyList<KeyValuePair<string, object?>> l:
             {
-                // this path is optimized in the real Logger implementation, so it is here too...
+                int count = l.Count;
+                for (int i = 0; i < count; i++)
+                {
+                    _ = ProcessItem(l[i]);
+                }
+
                 break;
             }
 
             case IEnumerable<KeyValuePair<string, object?>> enumerable:
             {
-                var l = _listPool.Get();
-
                 foreach (var e in enumerable)
                 {
-                    // Any non-primitive value type will be turned into a string on this path.
-                    // But when using the generated code, this conversion to string happens in the
-                    // generated code, which eliminates the overhead of boxing the value type.
-                    if (e.Value is Guid)
-                    {
-                        _ = e.Value.ToString();
-                    }
-
-                    l.Add(e);
+                    _ = ProcessItem(e);
                 }
 
-                _listPool.Return(l);
                 break;
             }
         }
     }
+
+    private static object? ProcessItem(in KeyValuePair<string, object?> item)
+    {
+        var o = item.Value;
+
+        if (o?.GetType() == typeof(Guid))
+        {
+            // simulate what a real exporter like OTel would do.
+            o = o.ToString();
+        }
+
+        return o;
+    }
 }

bench/Libraries/Microsoft.Extensions.Telemetry.PerformanceTests/BenchLoggerProvider.cs

@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Extensions.Telemetry.Bench;
+
+internal sealed class BenchLoggerProvider : ILoggerProvider
+{
+    public ILogger CreateLogger(string categoryName) => new BenchLogger();
+
+    public void Dispose()
+    {
+        // nop
+    }
+}

bench/Libraries/Microsoft.Extensions.Telemetry.PerformanceTests/ClassicCodeGen.cs

@@ -0,0 +1,16 @@
+// 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.Telemetry.Bench;
+
+internal static partial class ClassicCodeGen
+{
+    [LoggerMessage(LogLevel.Error, @"Connection id '{connectionId}' received {type} frame for stream ID {streamId} with length {length} and flags {flags} and {other}")]
+    public static partial void RefTypes(ILogger logger, string connectionId, string type, string streamId, string length, string flags, string other);
+
+    [LoggerMessage(LogLevel.Error, @"Range [{start}..{end}], options {options}, guid {guid}")]
+    public static partial void ValueTypes(ILogger logger, long start, long end, int options, Guid guid);
+}