Improve instrument name validation and log messages

src/OpenTelemetry/CHANGELOG.md

@@ -21,6 +21,9 @@ Notes](../../RELEASENOTES.md).
   }
   ```
 
+* Moved the `InstrumentNameRegex` from `MeterProviderBuilderSdk` to `Guard`.
+  ([#6457](https://github.com/open-telemetry/opentelemetry-dotnet/pull/6457))
+
 ## 1.12.0
 
 Released 2025-Apr-29

src/OpenTelemetry/Metrics/Builder/MeterProviderBuilderExtensions.cs

@@ -105,10 +105,7 @@ public static MeterProviderBuilder AddView(this MeterProviderBuilder meterProvid
     {
         Guard.ThrowIfNull(instrumentName);
 
-        if (!MeterProviderBuilderSdk.IsValidInstrumentName(name))
-        {
-            throw new ArgumentException($"Custom view name {name} is invalid.", nameof(name));
-        }
+        Guard.ThrowIfInvalidCustomViewName(name);
 
 #pragma warning disable CA1062 // Validate arguments of public methods - needed for netstandard2.1
 #if NET || NETSTANDARD2_1_OR_GREATER

src/OpenTelemetry/Metrics/Builder/MeterProviderBuilderSdk.cs

@@ -3,7 +3,6 @@
 
 using System.Diagnostics;
 using System.Diagnostics.Metrics;
-using System.Text.RegularExpressions;
 using Microsoft.Extensions.DependencyInjection;
 using OpenTelemetry.Internal;
 using OpenTelemetry.Resources;
@@ -27,14 +26,6 @@ public MeterProviderBuilderSdk(IServiceProvider serviceProvider)
         this.serviceProvider = serviceProvider;
     }
 
-    // Note: We don't use static readonly here because some customers
-    // replace this using reflection which is not allowed on initonly static
-    // fields. See: https://github.com/dotnet/runtime/issues/11571.
-    // Customers: This is not guaranteed to work forever. We may change this
-    // mechanism in the future do this at your own risk.
-    public static Regex InstrumentNameRegex { get; set; } = new(
-        @"^[a-z][a-z0-9-._/]{0,254}$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
-
     public List<InstrumentationRegistration> Instrumentation { get; } = new();
 
     public ResourceBuilder? ResourceBuilder { get; private set; }
@@ -53,39 +44,6 @@ public MeterProviderBuilderSdk(IServiceProvider serviceProvider)
 
     public int CardinalityLimit { get; private set; } = DefaultCardinalityLimit;
 
-    /// <summary>
-    /// Returns whether the given instrument name is valid according to the specification.
-    /// </summary>
-    /// <remarks>See specification: <see href="https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#instrument"/>.</remarks>
-    /// <param name="instrumentName">The instrument name.</param>
-    /// <returns>Boolean indicating if the instrument is valid.</returns>
-    public static bool IsValidInstrumentName(string instrumentName)
-    {
-        if (string.IsNullOrWhiteSpace(instrumentName))
-        {
-            return false;
-        }
-
-        return InstrumentNameRegex.IsMatch(instrumentName);
-    }
-
-    /// <summary>
-    /// Returns whether the given custom view name is valid according to the specification.
-    /// </summary>
-    /// <remarks>See specification: <see href="https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#instrument"/>.</remarks>
-    /// <param name="customViewName">The view name.</param>
-    /// <returns>Boolean indicating if the instrument is valid.</returns>
-    public static bool IsValidViewName(string customViewName)
-    {
-        // Only validate the view name in case it's not null. In case it's null, the view name will be the instrument name as per the spec.
-        if (customViewName == null)
-        {
-            return true;
-        }
-
-        return InstrumentNameRegex.IsMatch(customViewName);
-    }
-
     public void RegisterProvider(MeterProviderSdk meterProvider)
     {
         Debug.Assert(meterProvider != null, "meterProvider was null");

src/OpenTelemetry/Metrics/MeterProviderSdk.cs

@@ -260,7 +260,7 @@ internal static void MeasurementRecordedDouble(Instrument instrument, double val
 
             if (viewConfigCount <= 0)
             {
-                if (!MeterProviderBuilderSdk.IsValidInstrumentName(instrument.Name))
+                if (!Guard.IsValidInstrumentName(instrument.Name))
                 {
                     OpenTelemetrySdkEventSource.Log.MetricInstrumentIgnored(
                         instrument.Name,

src/OpenTelemetry/Metrics/Reader/MetricReaderExt.cs

@@ -126,13 +126,24 @@ internal virtual List<Metric> AddMetricWithViews(Instrument instrument, List<Met
                     ? this.exemplarFilterForHistograms ?? this.exemplarFilter
                     : this.exemplarFilter;
 
-                if (!MeterProviderBuilderSdk.IsValidInstrumentName(metricStreamIdentity.InstrumentName))
+                if (!Guard.IsValidInstrumentName(metricStreamIdentity.InstrumentName))
                 {
-                    OpenTelemetrySdkEventSource.Log.MetricInstrumentIgnored(
-                        metricStreamIdentity.InstrumentName,
-                        metricStreamIdentity.MeterName,
-                        "Metric name is invalid.",
-                        "The name must comply with the OpenTelemetry specification.");
+                    if (metricStreamConfig?.Name == null)
+                    {
+                        OpenTelemetrySdkEventSource.Log.MetricInstrumentIgnored(
+                            metricStreamIdentity.InstrumentName,
+                            metricStreamIdentity.MeterName,
+                            "Instrument name is invalid.",
+                            "The name must comply with the OpenTelemetry specification.");
+                    }
+                    else
+                    {
+                        OpenTelemetrySdkEventSource.Log.MetricInstrumentIgnored(
+                            metricStreamIdentity.InstrumentName,
+                            metricStreamIdentity.MeterName,
+                            "View name is invalid.",
+                            "The name must comply with the OpenTelemetry specification.");
+                    }
 
                     continue;
                 }

src/OpenTelemetry/Metrics/View/MetricStreamConfiguration.cs

@@ -37,10 +37,7 @@ public string? Name
         get => this.name;
         set
         {
-            if (value != null && !MeterProviderBuilderSdk.IsValidViewName(value))
-            {
-                throw new ArgumentException($"Custom view name {value} is invalid.", nameof(value));
-            }
+            Guard.ThrowIfInvalidViewName(value);
 
             this.name = value;
         }

src/Shared/Guard.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
 
 #pragma warning disable SA1402 // File may only contain a single type
 #pragma warning disable SA1403 // File may only contain a single namespace
@@ -46,8 +47,21 @@ namespace OpenTelemetry.Internal
     /// <summary>
     /// Methods for guarding against exception throwing values.
     /// </summary>
-    internal static class Guard
+    internal static partial class Guard
     {
+        // Note: We don't use static readonly here because some customers
+        // replace this using reflection which is not allowed on initonly static
+        // fields. See: https://github.com/dotnet/runtime/issues/11571.
+        // Customers: This is not guaranteed to work forever. We may change this
+        // mechanism in the future do this at your own risk.
+#if NET7_0_OR_GREATER
+        [GeneratedRegex(@"^[a-z][a-z0-9-._/]{0,254}$", RegexOptions.IgnoreCase)]
+        public static partial Regex InstrumentNameRegex();
+#else
+        public static Regex InstrumentNameRegex { get; set; } = new(
+            @"^[a-z][a-z0-9-._/]{0,254}$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+#endif
+
         /// <summary>
         /// Throw an exception if the value is null.
         /// </summary>
@@ -178,6 +192,84 @@ public static T ThrowIfNotOfType<T>([NotNull] object? value, [CallerArgumentExpr
             return result;
         }
 
+        /// <summary>
+        /// Throws an exception if the given view name is invalid according to the specification.
+        /// Null is valid because the instrument name will be used as the view name.
+        /// </summary>
+        /// <remarks>See specification: <see href="https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#instrument"/>.</remarks>
+        /// <param name="viewName">The view name.</param>
+        /// <param name="paramName">The parameter name to use in the thrown exception.</param>
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ThrowIfInvalidViewName(string? viewName, [CallerArgumentExpression(nameof(viewName))] string? paramName = null)
+        {
+            if (!IsValidViewName(viewName))
+            {
+                throw new ArgumentException($"View name {viewName} is invalid.", paramName);
+            }
+        }
+
+        /// <summary>
+        /// Throws an exception if the given custom view name is invalid according to the specification.
+        /// </summary>
+        /// <remarks>See specification: <see href="https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#instrument"/>.</remarks>
+        /// <param name="viewName">The view name.</param>
+        /// <param name="paramName">The parameter name to use in the thrown exception.</param>
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ThrowIfInvalidCustomViewName([NotNull] string? viewName, [CallerArgumentExpression(nameof(viewName))] string? paramName = null)
+#pragma warning disable CS8777 // Parameter must have a non-null value when exiting.
+        {
+            if (!IsValidInstrumentName(viewName))
+            {
+                throw new ArgumentException($"Custom view name {viewName} is invalid.", paramName);
+            }
+        }
+#pragma warning restore CS8777 // Parameter must have a non-null value when exiting.
+
+        /// <summary>
+        /// Returns whether the given instrument name is valid according to the specification.
+        /// </summary>
+        /// <remarks>See specification: <see href="https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#instrument"/>.</remarks>
+        /// <param name="instrumentName">The instrument name.</param>
+        /// <returns>Boolean indicating if the instrument is valid.</returns>
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsValidInstrumentName(string? instrumentName)
+        {
+            if (string.IsNullOrWhiteSpace(instrumentName))
+            {
+                return false;
+            }
+#if NET7_0_OR_GREATER
+            return InstrumentNameRegex().IsMatch(instrumentName);
+#else
+            return InstrumentNameRegex.IsMatch(instrumentName);
+#endif
+        }
+
+        /// <summary>
+        /// Returns whether the given custom view name is valid according to the specification.
+        /// </summary>
+        /// <remarks>See specification: <see href="https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#instrument"/>.</remarks>
+        /// <param name="customViewName">The view name.</param>
+        /// <returns>Boolean indicating if the instrument is valid.</returns>
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool IsValidViewName(string? customViewName)
+        {
+            // Only validate the view name in case it's not null. In case it's null, the view name will be the instrument name as per the spec.
+            if (customViewName == null)
+            {
+                return true;
+            }
+#if NET7_0_OR_GREATER
+            return InstrumentNameRegex().IsMatch(customViewName);
+#else
+            return InstrumentNameRegex.IsMatch(customViewName);
+#endif
+        }
+
         [DebuggerHidden]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static void Range<T>(T value, string? paramName, T min, T max, string? minName, string? maxName, string? message)