experimental API, suppress exceptions, AddMeter

src/OpenTelemetry.Api/Metrics/MeterProviderBuilder.cs

@@ -29,6 +29,10 @@ public abstract MeterProviderBuilder AddInstrumentation<TInstrumentation>(
 
     /// <summary>
     /// Adds given Meter names to the list of subscribed meters.
+    /// <remarks>
+    /// When multiple matchers are added for the same meter name, the <see cref="MeterProvider"/>
+    /// will enable a meter if its name matches at least one of the provided names.
+    /// </remarks>
     /// </summary>
     /// <param name="names">Meter names.</param>
     /// <returns>Returns <see cref="MeterProviderBuilder"/> for chaining.</returns>

src/OpenTelemetry.Api/Trace/TracerProviderBuilder.cs

@@ -31,6 +31,11 @@ public abstract TracerProviderBuilder AddInstrumentation<TInstrumentation>(
 
     /// <summary>
     /// Adds the given <see cref="ActivitySource"/> names to the list of subscribed sources.
+    ///
+    /// <remarks>
+    /// When multiple matchers are added for the same source name, the <see cref="TracerProvider"/>
+    /// will enable an ActivitySource if its name matches at least one of the provided names.
+    /// </remarks>
     /// </summary>
     /// <param name="names">Activity source names.</param>
     /// <returns>Returns <see cref="TracerProviderBuilder"/> for chaining.</returns>

src/OpenTelemetry/.publicApi/Experimental/PublicAPI.Unshipped.txt

@@ -55,3 +55,5 @@ static OpenTelemetry.Sdk.CreateLoggerProviderBuilder() -> OpenTelemetry.Logs.Log
 static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.UseOpenTelemetry(this Microsoft.Extensions.Logging.ILoggingBuilder! builder) -> Microsoft.Extensions.Logging.ILoggingBuilder!
 static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.UseOpenTelemetry(this Microsoft.Extensions.Logging.ILoggingBuilder! builder, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> Microsoft.Extensions.Logging.ILoggingBuilder!
 static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.UseOpenTelemetry(this Microsoft.Extensions.Logging.ILoggingBuilder! builder, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>? configureBuilder, System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>? configureOptions) -> Microsoft.Extensions.Logging.ILoggingBuilder!
+static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddSource(this OpenTelemetry.Trace.TracerProviderBuilder! tracerProviderBuilder, System.Predicate<System.Diagnostics.ActivitySource!>! sourcePredicate) -> OpenTelemetry.Trace.TracerProviderBuilder!
+static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddMeter(this OpenTelemetry.Metrics.MeterProviderBuilder! meterProviderBuilder, System.Predicate<System.Diagnostics.Metrics.Meter!>! meterPredicate) -> OpenTelemetry.Metrics.MeterProviderBuilder!

src/OpenTelemetry/.publicApi/Stable/PublicAPI.Unshipped.txt

@@ -10,4 +10,3 @@ static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithMetrics(this OpenTele
 static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithMetrics(this OpenTelemetry.IOpenTelemetryBuilder! builder, System.Action<OpenTelemetry.Metrics.MeterProviderBuilder!>! configure) -> OpenTelemetry.IOpenTelemetryBuilder!
 static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithTracing(this OpenTelemetry.IOpenTelemetryBuilder! builder) -> OpenTelemetry.IOpenTelemetryBuilder!
 static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithTracing(this OpenTelemetry.IOpenTelemetryBuilder! builder, System.Action<OpenTelemetry.Trace.TracerProviderBuilder!>! configure) -> OpenTelemetry.IOpenTelemetryBuilder!
-static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddSource(this OpenTelemetry.Trace.TracerProviderBuilder! tracerProviderBuilder, System.Predicate<System.Diagnostics.ActivitySource!>! sourcePredicate) -> OpenTelemetry.Trace.TracerProviderBuilder!

src/OpenTelemetry/Internal/OpenTelemetrySdkEventSource.cs

@@ -157,6 +157,24 @@ public void LoggerProcessStateSkipped<TState>()
         }
     }
 
+    [NonEvent]
+    public void ActivitySourcePredicateException(string sourceName, Exception ex)
+    {
+        if (this.IsEnabled(EventLevel.Warning, EventKeywords.All))
+        {
+            this.ActivitySourcePredicateException(sourceName, ex.ToInvariantString());
+        }
+    }
+
+    [NonEvent]
+    public void MeterPredicateException(string meterName, Exception ex)
+    {
+        if (this.IsEnabled(EventLevel.Warning, EventKeywords.All))
+        {
+            this.MeterPredicateException(meterName, ex.ToInvariantString());
+        }
+    }
+
     [Event(4, Message = "Unknown error in SpanProcessor event '{0}': '{1}'.", Level = EventLevel.Error)]
     public void SpanProcessorException(string evnt, string ex)
     {
@@ -346,6 +364,18 @@ public void MetricInstrumentRemoved(string instrumentName, string meterName)
         this.WriteEvent(53, instrumentName, meterName);
     }
 
+    [Event(54, Message = "Exception thrown when invoking ActivitySource predicate for source '{0}', ignoring it. Exception: '{1}'", Level = EventLevel.Warning)]
+    public void ActivitySourcePredicateException(string sourceName, string error)
+    {
+        this.WriteEvent(54, sourceName, error);
+    }
+
+    [Event(55, Message = "Exception thrown when invoking Meter predicate for meter name '{0}', ignoring it. Exception: '{1}'", Level = EventLevel.Warning)]
+    public void MeterPredicateException(string meterName, string error)
+    {
+        this.WriteEvent(55, meterName, error);
+    }
+
 #if DEBUG
     public class OpenTelemetryEventListener : EventListener
     {

src/OpenTelemetry/Metrics/Builder/MeterProviderBuilderExtensions.cs

@@ -196,6 +196,35 @@ public static MeterProviderBuilder AddView(this MeterProviderBuilder meterProvid
         return meterProviderBuilder;
     }
 
+#if EXPOSE_EXPERIMENTAL_FEATURES
+    /// <summary>
+    /// Adds a predicate for <see cref="Meter"/> that is used to determine
+    /// if <see cref="MeterProvider"/> should subscribe to the meter.
+    ///
+    /// <remarks>
+    /// When multiple predicates are added using this method or via <see cref="MeterProviderBuilder.AddMeter(string[])"/>,
+    /// the <see cref="MeterProvider"/> will enable a meter if at least one of the predicates returns true for it, or
+    /// if the meter name matches one provided in the <see cref="MeterProviderBuilder.AddMeter(string[])"/> overload.
+    /// </remarks>
+    /// </summary>
+    /// <param name="meterProviderBuilder"><see cref="MeterProviderBuilder"/>.</param>
+    /// <param name="meterPredicate">Meter predicate - if it returns true, OpenTelemetry subscribes to the corresponding meter.</param>
+    /// <returns>Returns <see cref="MeterProviderBuilder"/> for chaining.</returns>
+    public static MeterProviderBuilder AddMeter(this MeterProviderBuilder meterProviderBuilder, Predicate<Meter> meterPredicate)
+    {
+        Guard.ThrowIfNull(meterProviderBuilder);
+        meterProviderBuilder.ConfigureBuilder((_, builder) =>
+        {
+            if (builder is MeterProviderBuilderSdk meterProviderBuilderSdk)
+            {
+                meterProviderBuilderSdk.AddMeter(meterPredicate);
+            }
+        });
+
+        return meterProviderBuilder;
+    }
+#endif
+
     /// <summary>
     /// Sets the maximum number of Metric streams supported by the MeterProvider.
     /// When no Views are configured, every instrument will result in one metric stream,

src/OpenTelemetry/Metrics/Builder/MeterProviderBuilderSdk.cs

@@ -47,6 +47,8 @@ public MeterProviderBuilderSdk(IServiceProvider serviceProvider)
 
     public List<string> MeterSources { get; } = new();
 
+    public List<Predicate<Meter>> MeterSelectionPredicates { get; } = new();
+
     public List<Func<Instrument, MetricStreamConfiguration?>> ViewConfigs { get; } = new();
 
     public int MetricLimit { get; private set; } = DefaultMetricLimit;
@@ -166,6 +168,14 @@ public override MeterProviderBuilder AddMeter(params string[] names)
         return this;
     }
 
+    public MeterProviderBuilder AddMeter(Predicate<Meter> meterPredicate)
+    {
+        Guard.ThrowIfNull(meterPredicate);
+        this.MeterSelectionPredicates.Add(meterPredicate!);
+
+        return this;
+    }
+
     public MeterProviderBuilder AddReader(MetricReader reader)
     {
         Debug.Assert(reader != null, "reader was null");

src/OpenTelemetry/Metrics/MeterProviderSdk.cs

@@ -143,19 +143,7 @@ internal MeterProviderSdk(
         }
 
         // Setup Listener
-        if (state.MeterSources.Any(s => WildcardHelper.ContainsWildcard(s)))
-        {
-            var regex = WildcardHelper.GetWildcardRegex(state.MeterSources);
-            this.shouldListenTo = instrument => regex.IsMatch(instrument.Meter.Name);
-        }
-        else if (state.MeterSources.Any())
-        {
-            var meterSourcesToSubscribe = new HashSet<string>(state.MeterSources, StringComparer.OrdinalIgnoreCase);
-            this.shouldListenTo = instrument => meterSourcesToSubscribe.Contains(instrument.Meter.Name);
-        }
-
-        OpenTelemetrySdkEventSource.Log.MeterProviderSdkEvent($"Listening to following meters = \"{string.Join(";", state.MeterSources)}\".");
-
+        this.shouldListenTo = this.GetPredicate(state);
         this.listener = new MeterListener();
         var viewConfigCount = this.viewConfigs.Count;
 
@@ -187,6 +175,36 @@ internal MeterProviderSdk(
         OpenTelemetrySdkEventSource.Log.MeterProviderSdkEvent("MeterProvider built successfully.");
     }
 
+    private Func<Instrument, bool> GetPredicate(MeterProviderBuilderSdk state)
+    {
+        List<Predicate<Meter>> predicates = new List<Predicate<Meter>>();
+
+        if (state.MeterSources.Any())
+        {
+            predicates.Add(this.GetNamePredicate(state));
+        }
+
+        predicates.AddRange(state.MeterSelectionPredicates);
+
+        return (instrument) =>
+        {
+            bool shouldListen = false;
+            for (int i = 0; i < predicates.Count && !shouldListen; i++)
+            {
+                try
+                {
+                    shouldListen |= predicates[i](instrument.Meter);
+                }
+                catch (Exception ex)
+                {
+                    OpenTelemetrySdkEventSource.Log.MeterPredicateException(instrument.Meter.Name, ex);
+                }
+            }
+
+            return shouldListen;
+        };
+    }
+
     internal Resource Resource { get; }
 
     internal List<object> Instrumentations => this.instrumentations;
@@ -531,4 +549,18 @@ private void ApplySpecificationConfigurationKeys(IConfiguration configuration)
         }
 #endif
     }
+
+    private Predicate<Meter> GetNamePredicate(MeterProviderBuilderSdk state)
+    {
+        Debug.Assert(state.MeterSources.Any(), "Should only be called when there are name-based source predicates.");
+
+        if (state.MeterSources.Any(s => WildcardHelper.ContainsWildcard(s)))
+        {
+            var regex = WildcardHelper.GetWildcardRegex(state.MeterSources);
+            return meter => regex.IsMatch(meter.Name);
+        }
+
+        var meterSourcesToSubscribe = new HashSet<string>(state.MeterSources, StringComparer.OrdinalIgnoreCase);
+        return meter => meterSourcesToSubscribe.Contains(meter.Name);
+    }
 }

src/OpenTelemetry/Trace/Builder/TracerProviderBuilderExtensions.cs

@@ -237,9 +237,16 @@ public static TracerProviderBuilder AddProcessor(
         return tracerProviderBuilder;
     }
 
+#if EXPOSE_EXPERIMENTAL_FEATURES
     /// <summary>
-    /// Adds predicate for <see cref="ActivitySource"/> that will be used to determine
+    /// Adds a predicate for <see cref="ActivitySource"/> that is used to determine
     /// if <see cref="TracerProvider"/> should subscribe to the source.
+    ///
+    /// <remarks>
+    /// When multiple predicates are added using this method or via <see cref="TracerProviderBuilder.AddSource(string[])"/>,
+    /// the <see cref="TracerProvider"/> will enable an ActivitySource if at least one of the predicates returns true for it, or
+    /// if the ActivitySource name matches one provided in the <see cref="TracerProviderBuilder.AddSource(string[])"/> overload.
+    /// </remarks>
     /// </summary>
     /// <param name="tracerProviderBuilder"><see cref="TracerProviderBuilder"/>.</param>
     /// <param name="sourcePredicate">Activity Source predicate - if it returns true, OpenTelemetry subscribes to the corresponding source.</param>
@@ -257,6 +264,7 @@ public static TracerProviderBuilder AddSource(this TracerProviderBuilder tracerP
 
         return tracerProviderBuilder;
     }
+#endif
 
     /// <summary>
     /// Run the given actions to initialize the <see cref="TracerProvider"/>.

src/OpenTelemetry/Trace/TracerProviderSdk.cs

@@ -450,7 +450,14 @@ private Func<ActivitySource, bool> GetPredicate(TracerProviderBuilderSdk state)
             bool shouldListen = false;
             for (int i = 0; i < predicates.Count && !shouldListen; i++)
             {
-                shouldListen |= predicates[i](activitySource);
+                try
+                {
+                    shouldListen |= predicates[i](activitySource);
+                }
+                catch (Exception ex)
+                {
+                    OpenTelemetrySdkEventSource.Log.ActivitySourcePredicateException(activitySource.Name, ex);
+                }
             }
 
             return shouldListen;

test/OpenTelemetry.Tests/Metrics/MeterProviderSdkTest.cs

@@ -104,4 +104,107 @@ void RunTest()
             }
         }
     }
+
+    [Fact]
+    public void MeterProviderSdkAddMeterWithPredicate()
+    {
+        using var meter1 = new Meter($"{Utils.GetCurrentMethodName()}.A", "1.0.0");
+        using var meter2 = new Meter($"{Utils.GetCurrentMethodName()}.A", "2.0.0");
+        using var meter3 = new Meter($"{Utils.GetCurrentMethodName()}.B");
+        using var meter4 = new Meter($"B.{Utils.GetCurrentMethodName()}");
+
+        using (var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddMeter(meter => meter.Version == "2.0.0" || meter.Name.EndsWith(".B"))
+            .AddInMemoryExporter(new List<Metric>())
+            .Build())
+        {
+            Assert.False(IsMeterEnabled(meter1));
+            Assert.True(IsMeterEnabled(meter2));
+            Assert.True(IsMeterEnabled(meter3));
+            Assert.False(IsMeterEnabled(meter4));
+        }
+    }
+
+    [Fact]
+    public void MeterProviderSdkAddMeterWithPredicateException()
+    {
+        using var meter1 = new Meter($"{Utils.GetCurrentMethodName()}.A", "1.0.0");
+        using var meter2 = new Meter($"{Utils.GetCurrentMethodName()}.B");
+
+        using (var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddMeter(meter => meter.Version.StartsWith("1.0.0")) // throws!
+            .AddInMemoryExporter(new List<Metric>())
+            .Build())
+        {
+            Assert.True(IsMeterEnabled(meter1));
+            Assert.False(IsMeterEnabled(meter2));
+        }
+    }
+
+    [Fact]
+    public void MeterProviderSdkAddMeterWithMultiplePredicates()
+    {
+        using var meter1 = new Meter($"{Utils.GetCurrentMethodName()}.A", "1.0.0");
+        using var meter2 = new Meter($"{Utils.GetCurrentMethodName()}.A", "2.0.0");
+        using var meter3 = new Meter($"{Utils.GetCurrentMethodName()}.B");
+        using var meter4 = new Meter($"B.{Utils.GetCurrentMethodName()}");
+
+        using (var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddMeter(meter => meter.Version == "2.0.0")
+            .AddMeter(meter => meter.Name.StartsWith("B."))
+            .AddInMemoryExporter(new List<Metric>())
+            .Build())
+        {
+            Assert.False(IsMeterEnabled(meter1));
+            Assert.True(IsMeterEnabled(meter2));
+            Assert.False(IsMeterEnabled(meter3));
+            Assert.True(IsMeterEnabled(meter4));
+        }
+    }
+
+    [Fact]
+    public void MeterProviderSdkAddMeterWithWildCardAndPredicate()
+    {
+        using var meter1 = new Meter($"{Utils.GetCurrentMethodName()}.A", "1.0.0");
+        using var meter2 = new Meter($"{Utils.GetCurrentMethodName()}.A", "2.0.0");
+        using var meter3 = new Meter($"{Utils.GetCurrentMethodName()}.B");
+        using var meter4 = new Meter($"B.{Utils.GetCurrentMethodName()}");
+
+        using (var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddMeter(meter => meter.Version == "2.0.0")
+            .AddMeter("B.*")
+            .AddInMemoryExporter(new List<Metric>())
+            .Build())
+        {
+            Assert.False(IsMeterEnabled(meter1));
+            Assert.True(IsMeterEnabled(meter2));
+            Assert.False(IsMeterEnabled(meter3));
+            Assert.True(IsMeterEnabled(meter4));
+        }
+    }
+
+    [Fact]
+    public void MeterProviderSdkAddMeterWithConflictingWildCardAndPredicate()
+    {
+        using var meter1 = new Meter($"{Utils.GetCurrentMethodName()}.A", "1.0.0");
+        using var meter2 = new Meter($"{Utils.GetCurrentMethodName()}.B");
+        using var meter3 = new Meter($"B.{Utils.GetCurrentMethodName()}");
+
+        using (var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddMeter(meter => !meter.Name.StartsWith("B.*"))
+            .AddMeter("B.*")
+            .AddInMemoryExporter(new List<Metric>())
+            .Build())
+        {
+            Assert.True(IsMeterEnabled(meter1));
+            Assert.True(IsMeterEnabled(meter2));
+            Assert.True(IsMeterEnabled(meter3));
+        }
+    }
+
+    private static bool IsMeterEnabled(Meter meter)
+    {
+        var counter = meter.CreateCounter<int>("test");
+        return counter.Enabled;
+    }
 }

test/OpenTelemetry.Tests/Trace/TracerProviderSdkTest.cs

@@ -79,6 +79,21 @@ public void TracerProviderSdkAddSourceWithPredicate()
         }
     }
 
+    [Fact]
+    public void TracerProviderSdkAddSourceWithPredicateException()
+    {
+        using var source1 = new ActivitySource($"{Utils.GetCurrentMethodName()}.A", "1.0.0");
+        using var source2 = new ActivitySource($"{Utils.GetCurrentMethodName()}.B");
+
+        using (var tracerProvider = Sdk.CreateTracerProviderBuilder()
+            .AddSource(source => source.Version.StartsWith("1.0.0")) // throws!
+            .Build())
+        {
+            Assert.True(IsSourceEnabled(source1));
+            Assert.False(IsSourceEnabled(source2));
+        }
+    }
+
     [Fact]
     public void TracerProviderSdkAddSourceWithMultiplePredicates()
     {