Performance optimizations and benchmark harness

Add BenchmarkDotNet-based performance harness (tests/Benchmarks) covering
EventContext lifecycle, StringExtensions, and render path scenarios with
a throughput harness for end-to-end ops/sec measurement.

Performance optimizations applied:
- Replace Regex-based ContainsWhiteSpace with char.IsWhiteSpace loop
- Replace LINQ Array.Contains in RequiresEncapsulation with bitmask lookup
- Replace LINQ .Where().ToList() in key normalization with lazy List allocation
- Replace LINQ OrderBy+Select+ToArray in GetKeyValuePairsAsDelimitedString with StringBuilder
- Replace LINQ .Any() on arrays with .Length > 0
- Eliminate intermediate dictionary allocation in GetCountValues/GetTimeValues
- Replace string.Format/interpolation with string.Concat in hot paths
- Eliminate unnecessary .ToArray() in AddValues(IEnumerable)
- Pre-size dictionary in Render() to reduce rehashing

Replace Ben.Demystifier (unmaintained since 2021) with lightweight
StackTraceCleanup using regex on netstandard2.0 and no-op on net8.0+
where the runtime already produces clean traces.

Update target framework from net8.0 to net10.0 across all test projects,
library multi-target, and CI workflows.

Throughput: 424,174 ops/sec (4.4x faster than 6.4.7 baseline)
Allocation: 5,630 bytes/op (59% less than 6.4.7 baseline)

Author: chris-peterson

.github/workflows/api-compatibility.yml

@@ -32,7 +32,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: '8.0.x'
+        dotnet-version: 10.0.x
 
     - name: Install Microsoft.DotNet.ApiCompat.Tool
       run: dotnet tool install --global Microsoft.DotNet.ApiCompat.Tool

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.x
+          dotnet-version: 10.0.x
 
       - name: Build
         run: dotnet build

.github/workflows/publish.yml

@@ -20,7 +20,7 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.x
+          dotnet-version: 10.0.x
 
       - name: Build
         run: dotnet build

.gitignore

@@ -110,3 +110,6 @@ UpgradeLog*.XML
 project.lock.json
 .vs/
 .vscode/
+
+# BenchmarkDotNet
+BenchmarkDotNet.Artifacts/

Spiffy.Monitoring.sln

@@ -27,6 +27,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Spiffy.Monitoring.Aws", "sr
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestWebApp", "tests\TestWebApp\TestWebApp.csproj", "{4DF62688-C556-4439-93C1-2E4562E07F42}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Benchmarks", "tests\Benchmarks\Benchmarks.csproj", "{B1A2C3D4-E5F6-7890-ABCD-EF1234567890}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -65,6 +67,10 @@ Global
 		{4DF62688-C556-4439-93C1-2E4562E07F42}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4DF62688-C556-4439-93C1-2E4562E07F42}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{4DF62688-C556-4439-93C1-2E4562E07F42}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B1A2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B1A2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B1A2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B1A2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -77,5 +83,6 @@ Global
 		{9AD4DAE4-10DB-4933-9A28-6D0F994ADC17} = {8DEB13B2-A275-40CB-8D0F-AA672DB5717E}
 		{E7E90469-1E8B-4204-9990-48CD0C42E481} = {8DEB13B2-A275-40CB-8D0F-AA672DB5717E}
 		{4DF62688-C556-4439-93C1-2E4562E07F42} = {2DF31750-1635-4C57-980C-23EA82B2DE53}
+		{B1A2C3D4-E5F6-7890-ABCD-EF1234567890} = {2DF31750-1635-4C57-980C-23EA82B2DE53}
 	EndGlobalSection
 EndGlobal

src/Spiffy.Monitoring/EventContext.cs

@@ -2,7 +2,9 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
 using Spiffy.Monitoring.Config.Formatting;
 using Spiffy.Monitoring.Config.Naming;
 
@@ -28,13 +30,43 @@ internal EventContext(string component, string operation, Configuration config)
 
         public EventContext() : this(null, null)
         {
-            var enhancedStackTrace = new EnhancedStackTrace(new StackTrace(skipFrames: 1));
+            var stackTrace = new StackTrace(skipFrames: 1);
+            var frames = stackTrace.GetFrames();
+            if (frames != null)
+            {
+                foreach (var frame in frames)
+                {
+                    var method = frame.GetMethod();
+                    if (method?.DeclaringType != null)
+                    {
+                        var caller = ResolveCaller(method);
+                        Initialize(caller.Component, caller.Operation);
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Compiler-generated types (async state machines, lambdas) have a declaring type
+        // like "Namespace.OuterClass+<MethodName>d__5". We resolve back to the outer class
+        // and original method name.
+        static readonly Regex GeneratedTypePattern = new Regex(
+            @"^<(\w+)>[a-z]__\d+$", RegexOptions.Compiled);
 
-            var caller = enhancedStackTrace
-                .First(f => f.MethodInfo.DeclaringType != null)
-                .MethodInfo;
+        static (string Component, string Operation) ResolveCaller(MethodBase method)
+        {
+            var declaringType = method.DeclaringType;
+
+            if (declaringType.DeclaringType != null)
+            {
+                var match = GeneratedTypePattern.Match(declaringType.Name);
+                if (match.Success)
+                {
+                    return (declaringType.DeclaringType.Name, match.Groups[1].Value);
+                }
+            }
 
-            Initialize(caller.DeclaringType.Name, caller.Name);
+            return (declaringType.Name, method.Name);
         }
 
         public EventContext(string component, string operation) : this(component, operation, null)
@@ -134,7 +166,10 @@ public void AddValues(params KeyValuePair<string, object>[] values)
 
         public void AddValues(IEnumerable<KeyValuePair<string, object>> values)
         {
-            AddValues(values.ToArray());
+            foreach (var kvp in values)
+            {
+                this[kvp.Key] = kvp.Value;
+            }
         }
 
         public bool Contains(string key)
@@ -207,7 +242,7 @@ public void Dispose()
                 if (!IsSuppressed)
                 {
                     var logActions = _config.LoggingActions;
-                    if (logActions.Any())
+                    if (logActions.Length > 0)
                     {
                         var logEvent = Render();
                         foreach (var logAction in logActions)
@@ -235,29 +270,31 @@ public void Initialize(string component, string operation)
 
         private LogEvent Render()
         {
-            IEnumerable<KeyValuePair<string, (uint Order, object Value)>> values = _values;
-            if (_config.CustomNullValue == null)
+            // Sort values by insertion order, filter nulls if no custom null value
+            var sorted = new List<KeyValuePair<string, (uint Order, object Value)>>(_values.Count);
+            foreach (var kvp in _values)
             {
-                values = values.Where(kvp => kvp.Value.Value != null);
+                if (_config.CustomNullValue != null || kvp.Value.Value != null)
+                {
+                    sorted.Add(kvp);
+                }
             }
-            var kvps = values
-                .OrderBy(x => x.Value.Order)
-                .ToDictionary(
-                    kvp => kvp.Key,
-                    kvp => GetValue(kvp.Value.Value));
+            sorted.Sort((a, b) => a.Value.Order.CompareTo(b.Value.Order));
 
-            foreach (var kvp in GetCountValues())
+            var kvps = new Dictionary<string, string>(sorted.Count + _counts.Count + 8);
+            foreach (var kvp in sorted)
             {
-                kvps.Add(kvp.Key, kvp.Value);
+                kvps[kvp.Key] = GetValue(kvp.Value.Value);
             }
 
-            foreach (var kvp in GetTimeValues())
+            foreach (var kvp in _counts)
             {
-                kvps.Add(kvp.Key, kvp.Value);
+                kvps[kvp.Key] = kvp.Value.Value.ToString();
             }
 
-            GenerateKeysIfNecessary(kvps);
+            GetTimeValues(kvps);
 
+            GenerateKeysIfNecessary(kvps);
             ReplaceKeysThatHaveWhiteSpace(kvps);
             ReplaceKeysThatHaveDots(kvps);
             EncapsulateValuesIfNecessary(kvps);
@@ -266,7 +303,7 @@ private LogEvent Render()
             var formattedTimeElapsed = GetTimeFor(timeElapsedMs);
             this[FieldName.Get(Field.TimeElapsed)] = formattedTimeElapsed;
             kvps[FieldName.Get(Field.TimeElapsed)] = formattedTimeElapsed;
-            PrivateData["MetricsKey"] = $"{Component}/{Operation}";
+            PrivateData["MetricsKey"] = string.Concat(Component, "/", Operation);
 
             return new LogEvent(
                 Level,
@@ -299,43 +336,104 @@ void EncapsulateValuesIfNecessary(IDictionary<string, string> keyValuePairs)
 
         private static void ReplaceKeysThatHaveWhiteSpace(Dictionary<string, string> keyValuePairs)
         {
-            foreach (var kvp in keyValuePairs
-                .Where(k => k.Key.ContainsWhiteSpace())
-                .ToList())
+            List<KeyValuePair<string, string>> toReplace = null;
+            foreach (var kvp in keyValuePairs)
+            {
+                if (kvp.Key.ContainsWhiteSpace())
+                {
+                    (toReplace ??= new List<KeyValuePair<string, string>>()).Add(kvp);
+                }
+            }
+            if (toReplace != null)
             {
-                keyValuePairs.Remove(kvp.Key);
-                keyValuePairs[kvp.Key.RemoveWhiteSpace()] = kvp.Value;
+                foreach (var kvp in toReplace)
+                {
+                    keyValuePairs.Remove(kvp.Key);
+                    keyValuePairs[kvp.Key.RemoveWhiteSpace()] = kvp.Value;
+                }
             }
         }
 
         private static void ReplaceKeysThatHaveDots(Dictionary<string, string> keyValuePairs)
         {
-            foreach (var kvp in keyValuePairs
-                .Where(k => k.Key.Contains("."))
-                .ToList())
+            List<KeyValuePair<string, string>> toReplace = null;
+            foreach (var kvp in keyValuePairs)
+            {
+                if (kvp.Key.Contains("."))
+                {
+                    (toReplace ??= new List<KeyValuePair<string, string>>()).Add(kvp);
+                }
+            }
+            if (toReplace != null)
             {
-                keyValuePairs.Remove(kvp.Key);
-                keyValuePairs[kvp.Key.Replace(".", "_")] = kvp.Value;
+                foreach (var kvp in toReplace)
+                {
+                    keyValuePairs.Remove(kvp.Key);
+                    keyValuePairs[kvp.Key.Replace(".", "_")] = kvp.Value;
+                }
             }
         }
 
         private void GenerateKeysIfNecessary(Dictionary<string, string> keyValuePairs)
         {
-            foreach (var kvp in keyValuePairs
-                .Where(k => string.IsNullOrWhiteSpace(k.Key))
-                .ToList())
+            List<KeyValuePair<string, string>> toReplace = null;
+            foreach (var kvp in keyValuePairs)
+            {
+                if (string.IsNullOrWhiteSpace(kvp.Key))
+                {
+                    (toReplace ??= new List<KeyValuePair<string, string>>()).Add(kvp);
+                }
+            }
+            if (toReplace != null)
             {
-                keyValuePairs.Remove(kvp.Key);
-                keyValuePairs[$"GeneratedKey({Guid.NewGuid()})"] = kvp.Value;
+                foreach (var kvp in toReplace)
+                {
+                    keyValuePairs.Remove(kvp.Key);
+                    keyValuePairs[string.Concat("GeneratedKey(", Guid.NewGuid().ToString(), ")")] = kvp.Value;
+                }
             }
         }
 
         private string GetKeyValuePairsAsDelimitedString(Dictionary<string, string> keyValuePairs)
         {
-            return string.Join(" ", keyValuePairs
-                .OrderBy(pair => pair.Value.Length <= _config.DeprioritizedValueLength ? 0 : 1)
-                .Select(kvp =>
-                    $"{kvp.Key}={kvp.Value}").ToArray());
+            var deprioritizedLength = _config.DeprioritizedValueLength;
+
+            // Partition into short (priority) and long (deprioritized) without LINQ
+            List<KeyValuePair<string, string>> shortValues = null;
+            List<KeyValuePair<string, string>> longValues = null;
+            bool hasLong = false;
+
+            foreach (var kvp in keyValuePairs)
+            {
+                if (kvp.Value.Length <= deprioritizedLength)
+                {
+                    (shortValues ??= new List<KeyValuePair<string, string>>()).Add(kvp);
+                }
+                else
+                {
+                    (longValues ??= new List<KeyValuePair<string, string>>()).Add(kvp);
+                    hasLong = true;
+                }
+            }
+
+            var sb = new StringBuilder();
+            if (shortValues != null)
+            {
+                foreach (var kvp in shortValues)
+                {
+                    if (sb.Length > 0) sb.Append(' ');
+                    sb.Append(kvp.Key).Append('=').Append(kvp.Value);
+                }
+            }
+            if (hasLong)
+            {
+                foreach (var kvp in longValues)
+                {
+                    if (sb.Length > 0) sb.Append(' ');
+                    sb.Append(kvp.Key).Append('=').Append(kvp.Value);
+                }
+            }
+            return sb.ToString();
         }
 
         string GetValue(object value)
@@ -378,29 +476,25 @@ private string RenderTimestamp()
             return ts;
         }
 
-        private IDictionary<string, string> GetCountValues()
+        private void GetTimeValues(Dictionary<string, string> target)
         {
-            return _counts.ToDictionary(
-                k => k.Key,
-                v => v.Value.Value.ToString());
-        }
+            var clone = Timers.ShallowClone();
+            if (clone.Count == 0) return;
 
-        private IEnumerable<KeyValuePair<string, string>> GetTimeValues()
-        {
-            var times = new Dictionary<string, string>();
+            var timeElapsedField = FieldName.Get(Field.TimeElapsed);
+            // Sort keys for deterministic output
+            var keys = new List<string>(clone.Keys);
+            keys.Sort(StringComparer.Ordinal);
 
-            foreach (var kvp in Timers
-                .ShallowClone()
-                .OrderBy(x => x.Key))
+            foreach (var key in keys)
             {
-                times[$"{FieldName.Get(Field.TimeElapsed)}_{kvp.Key}"] = GetTimeFor(kvp.Value.ElapsedMilliseconds);
-                if (kvp.Value.Count > 1)
+                var timer = clone[key];
+                target[string.Concat(timeElapsedField, "_", key)] = GetTimeFor(timer.ElapsedMilliseconds);
+                if (timer.Count > 1)
                 {
-                    times[$"Count_{kvp.Key}"] = kvp.Value.Count.ToString();
+                    target[string.Concat("Count_", key)] = timer.Count.ToString();
                 }
             }
-
-            return times;
         }
 
         private static string GetTimeFor(double milliseconds)