copilot feedback fixes

Author: koenbeuk

docs/reference/telemetry.md

@@ -6,7 +6,7 @@ Every instrument is **zero-cost when no listener is attached**: counters and act
 
 ## Activity (Distributed Tracing)
 
-A single span is emitted from `ExpressiveSharp.ActivitySource`:
+A single span is emitted from the `ExpressiveSharp` `ActivitySource` (the source's name is also exposed as the constant `ExpressiveDiagnostics.SourceName`):
 
 | Span | Emitted from | Tags |
 |------|--------------|------|

docs/reference/troubleshooting.md

@@ -324,12 +324,17 @@ public double TotalWithTax => Total * (1 + TaxRate);  // Total is inlined
 
 ### How do I see what ExpressiveSharp is doing at runtime?
 
-Subscribe to the `ExpressiveSharp` `ActivitySource`, `Meter`, or `EventSource`. The metrics surface cache hit/miss ratios and per-expansion timings; the EventSource surfaces failure paths that ExpressiveSharp recovers from silently — registry static-ctor failures, hot-reload reset failures, and `[ExpressiveFor]` collisions.
-
-The fastest path is `dotnet-trace`, which needs no code changes:
+ExpressiveSharp emits three independent signals on the `ExpressiveSharp` source name — each requires a different out-of-process tool:
 
 ```sh
+# Failure events (registry static-ctor failures, hot-reload reset failures, [ExpressiveFor] collisions)
 dotnet-trace collect -n MyApp --providers ExpressiveSharp::Verbose
+
+# Metrics (cache hit/miss ratios, expansion timings, reflection-fallback rate)
+dotnet-counters monitor -n MyApp ExpressiveSharp
+
+# Distributed tracing (the Expressive.Expand activity span) — wire via OpenTelemetry,
+# see the Telemetry reference for the AddSource("ExpressiveSharp") snippet.
 ```
 
 See [Telemetry](./telemetry) for the full instrument and event reference.

src/ExpressiveSharp/Diagnostics/ExpressiveEventSource.cs

@@ -20,10 +20,14 @@ public void RegistryInitializationFailed(string assemblyName, string exceptionTy
     public void RegistryInitializationFailed(Assembly assembly, Exception exception)
     {
         if (!IsEnabled()) return;
+        // The caller catches TypeInitializationException, but the actionable cause is the
+        // static-ctor exception nested inside it — unwrap so consumers see the real failure.
+        var actual = exception is TypeInitializationException && exception.InnerException is { } inner
+            ? inner : exception;
         RegistryInitializationFailed(
             assembly.GetName().Name ?? "<unknown>",
-            exception.GetType().FullName ?? exception.GetType().Name,
-            exception.Message);
+            actual.GetType().FullName ?? actual.GetType().Name,
+            actual.Message);
     }
 
     [Event(2, Level = EventLevel.Warning,

src/ExpressiveSharp/Services/ExpressiveResolver.cs

@@ -106,18 +106,23 @@ internal static void SetAssemblyScanFilter(Func<Assembly, bool>? filter)
         public LambdaExpression FindGeneratedExpression(MemberInfo expressiveMemberInfo,
             ExpressiveAttribute? expressiveAttribute = null)
         {
-            if (ExpressiveDiagnostics.CacheHits.Enabled || ExpressiveDiagnostics.CacheMisses.Enabled)
+            // Hits are counted on the fast path; misses are counted inside the factory so that
+            // concurrent racing TryGetValue calls don't both pre-increment when only one factory
+            // actually runs. ConcurrentDictionary may still invoke the factory multiple times
+            // under contention, which can over-count by a tiny margin — acceptable for an
+            // observability counter.
+            if (ExpressiveDiagnostics.CacheHits.Enabled
+                && _expressionCache.TryGetValue(expressiveMemberInfo, out var cached))
             {
-                if (_expressionCache.TryGetValue(expressiveMemberInfo, out var cached))
-                {
-                    ExpressiveDiagnostics.CacheHits.Add(1);
-                    return cached;
-                }
-                ExpressiveDiagnostics.CacheMisses.Add(1);
+                ExpressiveDiagnostics.CacheHits.Add(1);
+                return cached;
             }
 
-            return _expressionCache.GetOrAdd(expressiveMemberInfo,
-                static (mi, _) => ResolveExpressionCore(mi), (object?)null);
+            return _expressionCache.GetOrAdd(expressiveMemberInfo, static (mi, _) =>
+            {
+                ExpressiveDiagnostics.CacheMisses.Add(1);
+                return ResolveExpressionCore(mi);
+            }, (object?)null);
         }
 
         /// <inheritdoc/>
@@ -256,6 +261,10 @@ private static LambdaExpression ResolveExpressionCore(MemberInfo expressiveMembe
         /// </summary>
         public static LambdaExpression? FindGeneratedExpressionViaReflection(MemberInfo expressiveMemberInfo)
         {
+            // ConcurrentDictionary.GetOrAdd may invoke the factory more than once under
+            // contention, which can over-count the counter by a small margin on cold concurrent
+            // lookups. Acceptable for an observability signal — the alternative (Lazy<T> wrapper)
+            // adds allocation on every lookup.
             var result = _reflectionCache.GetOrAdd(expressiveMemberInfo, static mi =>
             {
                 var built = BuildReflectionExpression(mi);