refactor(telemetry): standardize meter names and descriptions

Author: BenjaminAbt

src/HttpUserAgentParser.AspNetCore/HttpUserAgentParserAccessor.cs

@@ -14,11 +14,6 @@ namespace MyCSharp.HttpUserAgentParser.AspNetCore;
 public class HttpUserAgentParserAccessor(IHttpUserAgentParserProvider httpUserAgentParser)
     : IHttpUserAgentParserAccessor
 {
-    /// <summary>
-    /// The name of the Meter used for metrics.
-    /// </summary>
-    public const string MeterName = "MyCSharp.HttpUserAgentParser.AspNetCore";
-
     private readonly IHttpUserAgentParserProvider _httpUserAgentParser = httpUserAgentParser;
 
     /// <summary>

src/HttpUserAgentParser.AspNetCore/Telemetry/HttpUserAgentParserAspNetCoreMeters.cs

@@ -20,7 +20,7 @@ internal static class HttpUserAgentParserAspNetCoreMeters
     /// <summary>
     /// Name of the meter used to publish AspNetCore User-Agent metrics.
     /// </summary>
-    public const string MeterName = HttpUserAgentParserAccessor.MeterName;
+    public const string MeterName = "mycsharp.http_user_agent_parser.aspnetcore";
 
     /// <summary>
     /// Indicates whether the meter and its instruments have been initialized.

src/HttpUserAgentParser.AspNetCore/readme.md

@@ -58,8 +58,8 @@ services
 
 EventSource: `MyCSharp.HttpUserAgentParser.AspNetCore` (constant: `HttpUserAgentParserAspNetCoreEventSource.EventSourceName`)
 
-- `useragent-present` (incrementing)
-- `useragent-missing` (incrementing)
+- `user_agent.present` (incrementing)
+- `user_agent.missing` (incrementing)
 
 ### Monitor with dotnet-counters
 
@@ -83,8 +83,8 @@ services
 
 Meter: `MyCSharp.HttpUserAgentParser.AspNetCore` (constant: `HttpUserAgentParserAspNetCoreMeters.MeterName`)
 
-- `useragent-present` (counter)
-- `useragent-missing` (counter)
+- `user_agent.present` (counter)
+- `user_agent.missing` (counter)
 
 ## Export to OpenTelemetry / Application Insights
 

src/HttpUserAgentParser.MemoryCache/HttpUserAgentParserMemoryCachedProvider.cs

@@ -18,7 +18,7 @@ public class HttpUserAgentParserMemoryCachedProvider(
     /// <summary>
     /// The name of the Meter used for metrics.
     /// </summary>
-    public const string MeterName = "MyCSharp.HttpUserAgentParser.MemoryCache";
+    public const string MeterName = "mycsharp.http_user_agent_parser.memorycache";
 
     private readonly Microsoft.Extensions.Caching.Memory.MemoryCache _memoryCache = new(options.CacheOptions);
     private readonly HttpUserAgentParserMemoryCachedProviderOptions _options = options;

src/HttpUserAgentParser.MemoryCache/Telemetry/HttpUserAgentParserMemoryCacheMeters.cs

@@ -35,18 +35,18 @@ public static void Enable(Meter? meter = null)
         s_cacheHit = s_meter.CreateCounter<long>(
             name: "cache.hit",
             unit: "{call}",
-            description: "MemoryCache cache hit");
+            description: "Cache hit");
 
         s_cacheMiss = s_meter.CreateCounter<long>(
             name: "cache.miss",
             unit: "{call}",
-            description: "MemoryCache cache miss");
+            description: "Cache miss");
 
         s_cacheSize = s_meter.CreateObservableGauge<long>(
             name: "cache.size",
             observeValue: static () => HttpUserAgentParserMemoryCacheTelemetryState.CacheSize,
             unit: "{entry}",
-            description: "MemoryCache cache size");
+            description: "Cache size");
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/HttpUserAgentParser.MemoryCache/readme.md

@@ -68,9 +68,9 @@ services
 
 EventSource: `MyCSharp.HttpUserAgentParser.MemoryCache` (constant: `HttpUserAgentParserMemoryCacheEventSource.EventSourceName`)
 
-- `cache-hit` (incrementing)
-- `cache-miss` (incrementing)
-- `cache-size` (polling)
+- `user_agent_parser.cache.hit` (incrementing)
+- `user_agent_parser.cache.miss` (incrementing)
+- `user_agent_parser.cache.size` (polling)
 
 ### Monitor with dotnet-counters
 
@@ -103,9 +103,9 @@ services
 
 Meter: `MyCSharp.HttpUserAgentParser.MemoryCache` (constant: `HttpUserAgentParserMemoryCacheMeters.MeterName`)
 
-- `cache-hit` (counter)
-- `cache-miss` (counter)
-- `cache-size` (observable gauge)
+- `user_agent_parser.cache.hit` (counter)
+- `user_agent_parser.cache.miss` (counter)
+- `user_agent_parser.cache.size` (observable gauge)
 
 ## Export to OpenTelemetry / Application Insights
 

src/HttpUserAgentParser/HttpUserAgentParser.cs

@@ -16,11 +16,6 @@ namespace MyCSharp.HttpUserAgentParser;
 /// </summary>
 public static class HttpUserAgentParser
 {
-    /// <summary>
-    /// The name of the Meter used for metrics.
-    /// </summary>
-    public const string MeterName = "MyCSharp.HttpUserAgentParser";
-
     /// <summary>
     /// Parses given <param name="userAgent">user agent</param>
     /// </summary>

src/HttpUserAgentParser/Telemetry/HttpUserAgentParserEventSource.cs

@@ -30,9 +30,9 @@ public sealed class HttpUserAgentParserEventSource : EventSource
     private readonly IncrementingEventCounter _parseRequests;
     private readonly EventCounter? _parseDurationSeconds;
 
-    private readonly IncrementingEventCounter _concurrentCacheHit;
-    private readonly IncrementingEventCounter _concurrentCacheMiss;
-    private readonly PollingCounter _concurrentCacheSize;
+    private readonly IncrementingEventCounter _cacheHit;
+    private readonly IncrementingEventCounter _cacheMiss;
+    private readonly PollingCounter _cacheSize;
 
     /// <summary>
     /// Initializes all EventCounters and polling counters used by this EventSource.
@@ -53,24 +53,24 @@ private HttpUserAgentParserEventSource()
         };
 
         // Providers (cache)
-        _concurrentCacheHit = new IncrementingEventCounter("cache-concurrentdictionary-hit", this)
+        _cacheHit = new IncrementingEventCounter("cache-hit", this)
         {
-            DisplayName = "ConcurrentDictionary cache hit",
+            DisplayName = "Cache hit",
             DisplayUnits = "calls",
         };
 
-        _concurrentCacheMiss = new IncrementingEventCounter("cache-concurrentdictionary-miss", this)
+        _cacheMiss = new IncrementingEventCounter("cache-miss", this)
         {
-            DisplayName = "ConcurrentDictionary cache miss",
+            DisplayName = "Cache miss",
             DisplayUnits = "calls",
         };
 
-        _concurrentCacheSize = new PollingCounter(
-            "cache-concurrentdictionary-size",
+        _cacheSize = new PollingCounter(
+            "cache-size",
             this,
             static () => HttpUserAgentParserTelemetryState.ConcurrentCacheSize)
         {
-            DisplayName = "ConcurrentDictionary cache size",
+            DisplayName = "Cache size",
             DisplayUnits = "entries",
         };
     }
@@ -105,43 +105,43 @@ internal void ParseDuration(double seconds)
     }
 
     /// <summary>
-    /// Records a cache hit in the concurrent dictionary provider.
+    /// Records a cache hit.
     /// </summary>
     [NonEvent]
-    internal void ConcurrentCacheHit()
+    internal void CacheHit()
     {
         if (!IsEnabled())
         {
             return;
         }
 
-        _concurrentCacheHit?.Increment();
+        _cacheHit?.Increment();
     }
 
     /// <summary>
-    /// Records a cache miss in the concurrent dictionary provider.
+    /// Records a cache miss.
     /// </summary>
     [NonEvent]
-    internal void ConcurrentCacheMiss()
+    internal void CacheMiss()
     {
         if (!IsEnabled())
         {
             return;
         }
 
-        _concurrentCacheMiss?.Increment();
+        _cacheMiss?.Increment();
     }
 
     /// <summary>
-    /// Updates the concurrent cache size used by the polling counter.
+    /// Updates the size used by the polling counter.
     /// </summary>
     /// <param name="size">Current number of entries in the cache.</param>
     /// <remarks>
     /// The size is updated even when telemetry is disabled so that the polling
     /// counter reports a correct value once a listener attaches.
     /// </remarks>
     [NonEvent]
-    internal static void ConcurrentCacheSizeSet(int size) => HttpUserAgentParserTelemetryState.SetConcurrentCacheSize(size);
+    internal static void CacheSizeSet(int size) => HttpUserAgentParserTelemetryState.SetConcurrentCacheSize(size);
 
     /// <summary>
     /// Releases all EventCounter and PollingCounter resources used by this EventSource.
@@ -157,9 +157,9 @@ protected override void Dispose(bool disposing)
             _parseRequests?.Dispose();
             _parseDurationSeconds?.Dispose();
 
-            _concurrentCacheHit?.Dispose();
-            _concurrentCacheMiss?.Dispose();
-            _concurrentCacheSize?.Dispose();
+            _cacheHit?.Dispose();
+            _cacheMiss?.Dispose();
+            _cacheSize?.Dispose();
         }
 
         base.Dispose(disposing);

src/HttpUserAgentParser/Telemetry/HttpUserAgentParserMeters.cs

@@ -20,7 +20,7 @@ internal static class HttpUserAgentParserMeters
     /// <summary>
     /// The meter name used for all instruments.
     /// </summary>
-    public const string MeterName = HttpUserAgentParser.MeterName;
+    public const string MeterName = "mycsharp.http_user_agent_parser";
 
     private static int s_initialized;
 
@@ -69,20 +69,20 @@ public static void Enable(Meter? meter = null)
             description: "Parse duration");
 
         s_concurrentCacheHit = s_meter.CreateCounter<long>(
-            name: "cache.concurrent_dictionary.hit",
+            name: "cache.hit",
             unit: "{call}",
-            description: "ConcurrentDictionary cache hit");
+            description: "Cache hit");
 
         s_concurrentCacheMiss = s_meter.CreateCounter<long>(
-            name: "cache.concurrent_dictionary.miss",
+            name: "cache.miss",
             unit: "{call}",
-            description: "ConcurrentDictionary cache miss");
+            description: "Cache miss");
 
         s_concurrentCacheSize = s_meter.CreateObservableGauge<long>(
-            name: "cache.concurrent_dictionary.size",
+            name: "cache.size",
             observeValue: static () => HttpUserAgentParserTelemetryState.ConcurrentCacheSize,
             unit: "{entry}",
-            description: "ConcurrentDictionary cache size");
+            description: "Cache size");
     }
 
     /// <summary>
@@ -98,16 +98,16 @@ public static void Enable(Meter? meter = null)
     public static void ParseDuration(double seconds) => s_parseDuration?.Record(seconds);
 
     /// <summary>
-    /// Emits a counter increment for a concurrent dictionary cache hit.
+    /// Emits a counter increment for a cache hit.
     /// </summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static void ConcurrentCacheHit() => s_concurrentCacheHit?.Add(1);
+    public static void CacheHit() => s_concurrentCacheHit?.Add(1);
 
     /// <summary>
-    /// Emits a counter increment for a concurrent dictionary cache miss.
+    /// Emits a counter increment for a cache miss.
     /// </summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static void ConcurrentCacheMiss() => s_concurrentCacheMiss?.Add(1);
+    public static void CacheMiss() => s_concurrentCacheMiss?.Add(1);
 
     /// <summary>
     /// Resets static state to support isolated unit tests.

src/HttpUserAgentParser/Telemetry/HttpUserAgentParserTelemetry.cs

@@ -117,12 +117,12 @@ public static void ConcurrentCacheHit()
         int flags = Volatile.Read(ref s_enabledFlags);
         if ((flags & EventCountersFlag) != 0)
         {
-            HttpUserAgentParserEventSource.Log.ConcurrentCacheHit();
+            HttpUserAgentParserEventSource.Log.CacheHit();
         }
 
         if ((flags & MetersFlag) != 0)
         {
-            HttpUserAgentParserMeters.ConcurrentCacheHit();
+            HttpUserAgentParserMeters.CacheHit();
         }
     }
 
@@ -135,12 +135,12 @@ public static void ConcurrentCacheMiss()
         int flags = Volatile.Read(ref s_enabledFlags);
         if ((flags & EventCountersFlag) != 0)
         {
-            HttpUserAgentParserEventSource.Log.ConcurrentCacheMiss();
+            HttpUserAgentParserEventSource.Log.CacheMiss();
         }
 
         if ((flags & MetersFlag) != 0)
         {
-            HttpUserAgentParserMeters.ConcurrentCacheMiss();
+            HttpUserAgentParserMeters.CacheMiss();
         }
     }