Size based EventId LogEventProperty cache

src/Serilog.Extensions.Logging/Extensions/Logging/EventIdPropertyCache.cs

@@ -0,0 +1,103 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Serilog.Extensions.Logging
+{
+    using Microsoft.Extensions.Logging;
+    using Serilog.Events;
+
+    internal sealed class EventIdPropertyCache
+    {
+        private readonly object _createLock = new();
+        private readonly int _maxCapacity;
+        private readonly Dictionary<EventKey, LogEventProperty> _propertyCache;
+
+        private int count;
+
+        public EventIdPropertyCache(int maxCapacity)
+        {
+            _maxCapacity = maxCapacity;
+            _propertyCache = new Dictionary<EventKey, LogEventProperty>(capacity: maxCapacity);
+        }
+
+        public LogEventProperty GetOrCreateProperty(in EventId eventId)
+        {
+            var eventKey = new EventKey(eventId);
+
+            if (_propertyCache.TryGetValue(eventKey, out var cachedProperty))
+            {
+                return cachedProperty;
+            }
+
+            lock (_createLock)
+            {
+                // Double check under lock
+                if (_propertyCache.TryGetValue(eventKey, out cachedProperty))
+                {
+                    return cachedProperty;
+                }
+
+                cachedProperty = CreateCore(in eventKey);
+
+                if (count < _maxCapacity)
+                {
+                    _propertyCache[eventKey] = cachedProperty;
+                    count++;
+                }
+
+                return cachedProperty;
+            }
+        }
+
+        private static LogEventProperty CreateCore(in EventKey eventKey)
+        {
+            var properties = new List<LogEventProperty>(2);
+
+            if (eventKey.Id != 0)
+            {
+                properties.Add(new LogEventProperty("Id", new ScalarValue(eventKey.Id)));
+            }
+
+            if (eventKey.Name != null)
+            {
+                properties.Add(new LogEventProperty("Name", new ScalarValue(eventKey.Name)));
+            }
+
+            return new LogEventProperty("EventId", new StructureValue(properties));
+        }
+
+        private readonly struct EventKey : IEquatable<EventKey>
+        {
+
+            public EventKey(EventId eventId)
+            {
+                Id = eventId.Id;
+                Name = eventId.Name;
+            }
+
+            public int Id { get; }
+
+            public string? Name { get; }
+
+            /// <inheritdoc />
+            public override int GetHashCode()
+            {
+                unchecked
+                {
+                    var hashCode = 17;
+
+                    hashCode = (hashCode * 397) ^ this.Id;
+                    hashCode = (hashCode * 397) ^ (this.Name?.GetHashCode() ?? 0);
+
+                    return hashCode;
+                }
+            }
+
+            /// <inheritdoc />
+            public bool Equals(EventKey other) => this.Id == other.Id && this.Name == other.Name;
+
+            /// <inheritdoc />
+            public override bool Equals(object? obj) => obj is EventKey other && Equals(other);
+        }
+    }
+}

src/Serilog.Extensions.Logging/Extensions/Logging/SerilogLogger.cs

@@ -29,12 +29,9 @@ internal static string GetKeyWithoutFirstSymbol(ConcurrentDictionary<string, str
     readonly SerilogLoggerProvider _provider;
     readonly ILogger _logger;
 
-    static readonly CachingMessageTemplateParser MessageTemplateParser = new();
+    readonly EventIdPropertyCache _eventPropertyCache = new (48);
 
-    // It's rare to see large event ids, as they are category-specific
-    static readonly LogEventProperty[] LowEventIdValues = Enumerable.Range(0, 48)
-        .Select(n => new LogEventProperty("Id", new ScalarValue(n)))
-        .ToArray();
+    static readonly CachingMessageTemplateParser MessageTemplateParser = new();
 
     public SerilogLogger(
         SerilogLoggerProvider provider,
@@ -155,7 +152,7 @@ LogEvent PrepareWrite<TState>(LogEventLevel level, EventId eventId, TState state
         }
 
         if (eventId.Id != 0 || eventId.Name != null)
-            properties.Add(CreateEventIdProperty(eventId));
+            properties.Add(this._eventPropertyCache.GetOrCreateProperty(in eventId));
 
         var (traceId, spanId) = Activity.Current is { } activity ?
             (activity.TraceId, activity.SpanId) :
@@ -172,25 +169,4 @@ LogEvent PrepareWrite<TState>(LogEventLevel level, EventId eventId, TState state
             stateObj = formatter(state, null);
         return stateObj ?? state;
     }
-
-    internal static LogEventProperty CreateEventIdProperty(EventId eventId)
-    {
-        var properties = new List<LogEventProperty>(2);
-
-        if (eventId.Id != 0)
-        {
-            if (eventId.Id >= 0 && eventId.Id < LowEventIdValues.Length)
-                // Avoid some allocations
-                properties.Add(LowEventIdValues[eventId.Id]);
-            else
-                properties.Add(new LogEventProperty("Id", new ScalarValue(eventId.Id)));
-        }
-
-        if (eventId.Name != null)
-        {
-            properties.Add(new LogEventProperty("Name", new ScalarValue(eventId.Name)));
-        }
-
-        return new LogEventProperty("EventId", new StructureValue(properties));
-    }
 }

test/Serilog.Extensions.Logging.Benchmarks/LogEventBenchmark.cs

@@ -34,6 +34,7 @@ private class Person
 
         readonly IMelLogger _melLogger;
         readonly Person _bob, _alice;
+        readonly EventId _eventId = new EventId(1, "Test");
 
         public LogEventBenchmark()
         {
@@ -61,5 +62,16 @@ public void LogInformationScoped()
             using (var scope = _melLogger.BeginScope("Hi {@User} from {$Me}", _bob, _alice))
                 _melLogger.LogInformation("Hi");
         }
+
+        [Benchmark]
+        public void LogInformation_WithEventId()
+        {
+            this._melLogger.Log(
+                LogLevel.Information,
+                _eventId,
+                "Hi {@User} from {$Me}",
+                _bob,
+                _alice);
+        }
     }
 }

test/Serilog.Extensions.Logging.Tests/EventIdPropertyCacheTests.cs

@@ -0,0 +1,36 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.Extensions.Logging;
+using Serilog.Events;
+using Xunit;
+
+namespace Serilog.Extensions.Logging.Tests
+{
+    public class EventIdPropertyCacheTests
+    {
+        [Theory]
+        [InlineData(1)]
+        [InlineData(10)]
+        [InlineData(48)]
+        [InlineData(100)]
+        public void LowAndHighNumberedEventIdsAreMapped(int id)
+        {
+            // Arrange
+            var cache = new EventIdPropertyCache(48);
+
+            var eventId = new EventId(id, "test");
+
+            // Act
+            var mapped = cache.GetOrCreateProperty(eventId);
+
+            // Assert
+            var value = Assert.IsType<StructureValue>(mapped.Value);
+            Assert.Equal(2, value.Properties.Count);
+
+            var idValue = value.Properties.Single(p => p.Name == "Id").Value;
+            var scalar = Assert.IsType<ScalarValue>(idValue);
+            Assert.Equal(id, scalar.Value);
+        }
+    }
+}

test/Serilog.Extensions.Logging.Tests/SerilogLoggerTests.cs

@@ -517,22 +517,6 @@ public void Dispose()
         }
     }
 
-    [Theory]
-    [InlineData(1)]
-    [InlineData(10)]
-    [InlineData(48)]
-    [InlineData(100)]
-    public void LowAndHighNumberedEventIdsAreMapped(int id)
-    {
-        var orig = new EventId(id, "test");
-        var mapped = SerilogLogger.CreateEventIdProperty(orig);
-        var value = Assert.IsType<StructureValue>(mapped.Value);
-        Assert.Equal(2, value.Properties.Count);
-        var idValue = value.Properties.Single(p => p.Name == "Id").Value;
-        var scalar = Assert.IsType<ScalarValue>(idValue);
-        Assert.Equal(id, scalar.Value);
-    }
-
     [Fact]
     public void MismatchedMessageTemplateParameterCountIsHandled()
     {