Metric Views: MetricStreamConfiguration API improvements (Version 2) (#3117)

2022-03-30 18:11:26 -07:00 · 2022-03-30 18:11:26 -07:00 · f4406b1bbb
parent ae4cbceaf1
commit f4406b1bbb
9 changed files with 227 additions and 106 deletions
--- a/src/OpenTelemetry/.publicApi/net461/PublicAPI.Unshipped.txt
+++ b/src/OpenTelemetry/.publicApi/net461/PublicAPI.Unshipped.txt
@ -1,6 +1,10 @@
 OpenTelemetry.BaseExporter<T>.ForceFlush(int timeoutMilliseconds = -1) -> bool
 OpenTelemetry.Batch<T>.Batch(T[] items, int count) -> void
 OpenTelemetry.Batch<T>.Count.get -> long
+OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration
+OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.get -> double[]
+OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.set -> void
+OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.ExplicitBucketHistogramConfiguration() -> void
 OpenTelemetry.Metrics.MetricReaderOptions
 OpenTelemetry.Metrics.MetricReaderOptions.MetricReaderOptions() -> void
 OpenTelemetry.Metrics.MetricReaderOptions.PeriodicExportingMetricReaderOptions.get -> OpenTelemetry.Metrics.PeriodicExportingMetricReaderOptions
@ -45,10 +49,6 @@ OpenTelemetry.Metrics.ExportModes.Push = 1 -> OpenTelemetry.Metrics.ExportModes
 OpenTelemetry.Metrics.ExportModesAttribute
 OpenTelemetry.Metrics.ExportModesAttribute.ExportModesAttribute(OpenTelemetry.Metrics.ExportModes supported) -> void
 OpenTelemetry.Metrics.ExportModesAttribute.Supported.get -> OpenTelemetry.Metrics.ExportModes
-OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration
-OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.get -> double[]
-OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.set -> void
-OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.ExplicitBucketHistogramConfiguration() -> void
 OpenTelemetry.Metrics.IPullMetricExporter
 OpenTelemetry.Metrics.IPullMetricExporter.Collect.get -> System.Func<int, bool>
 OpenTelemetry.Metrics.IPullMetricExporter.Collect.set -> void
@ -136,13 +136,13 @@ static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.SetResourceBuilder(t
 static OpenTelemetry.Metrics.MeterProviderExtensions.ForceFlush(this OpenTelemetry.Metrics.MeterProvider provider, int timeoutMilliseconds = -1) -> bool
 static OpenTelemetry.Metrics.MeterProviderExtensions.Shutdown(this OpenTelemetry.Metrics.MeterProvider provider, int timeoutMilliseconds = -1) -> bool
 static OpenTelemetry.Metrics.MeterProviderExtensions.TryFindExporter<T>(this OpenTelemetry.Metrics.MeterProvider provider, out T exporter) -> bool
+static OpenTelemetry.Metrics.MetricStreamConfiguration.Drop.get -> OpenTelemetry.Metrics.MetricStreamConfiguration
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsDouble(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsGauge(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsHistogram(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsLong(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsSum(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Sdk.CreateMeterProviderBuilder() -> OpenTelemetry.Metrics.MeterProviderBuilder
-static readonly OpenTelemetry.Metrics.MetricStreamConfiguration.Drop -> OpenTelemetry.Metrics.MetricStreamConfiguration
 virtual OpenTelemetry.BaseExporter<T>.OnForceFlush(int timeoutMilliseconds) -> bool
 virtual OpenTelemetry.Metrics.MetricReader.Dispose(bool disposing) -> void
 virtual OpenTelemetry.Metrics.MetricReader.OnCollect(int timeoutMilliseconds) -> bool
--- a/src/OpenTelemetry/.publicApi/netstandard2.0/PublicAPI.Unshipped.txt
+++ b/src/OpenTelemetry/.publicApi/netstandard2.0/PublicAPI.Unshipped.txt
@ -1,6 +1,10 @@
 OpenTelemetry.BaseExporter<T>.ForceFlush(int timeoutMilliseconds = -1) -> bool
 OpenTelemetry.Batch<T>.Batch(T[] items, int count) -> void
 OpenTelemetry.Batch<T>.Count.get -> long
+OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration
+OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.get -> double[]
+OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.set -> void
+OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.ExplicitBucketHistogramConfiguration() -> void
 OpenTelemetry.Metrics.MetricReaderOptions
 OpenTelemetry.Metrics.MetricReaderOptions.MetricReaderOptions() -> void
 OpenTelemetry.Metrics.MetricReaderOptions.PeriodicExportingMetricReaderOptions.get -> OpenTelemetry.Metrics.PeriodicExportingMetricReaderOptions
@ -45,10 +49,6 @@ OpenTelemetry.Metrics.ExportModes.Push = 1 -> OpenTelemetry.Metrics.ExportModes
 OpenTelemetry.Metrics.ExportModesAttribute
 OpenTelemetry.Metrics.ExportModesAttribute.ExportModesAttribute(OpenTelemetry.Metrics.ExportModes supported) -> void
 OpenTelemetry.Metrics.ExportModesAttribute.Supported.get -> OpenTelemetry.Metrics.ExportModes
-OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration
-OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.get -> double[]
-OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.set -> void
-OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.ExplicitBucketHistogramConfiguration() -> void
 OpenTelemetry.Metrics.IPullMetricExporter
 OpenTelemetry.Metrics.IPullMetricExporter.Collect.get -> System.Func<int, bool>
 OpenTelemetry.Metrics.IPullMetricExporter.Collect.set -> void
@ -136,13 +136,13 @@ static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.SetResourceBuilder(t
 static OpenTelemetry.Metrics.MeterProviderExtensions.ForceFlush(this OpenTelemetry.Metrics.MeterProvider provider, int timeoutMilliseconds = -1) -> bool
 static OpenTelemetry.Metrics.MeterProviderExtensions.Shutdown(this OpenTelemetry.Metrics.MeterProvider provider, int timeoutMilliseconds = -1) -> bool
 static OpenTelemetry.Metrics.MeterProviderExtensions.TryFindExporter<T>(this OpenTelemetry.Metrics.MeterProvider provider, out T exporter) -> bool
+static OpenTelemetry.Metrics.MetricStreamConfiguration.Drop.get -> OpenTelemetry.Metrics.MetricStreamConfiguration
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsDouble(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsGauge(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsHistogram(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsLong(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Metrics.MetricTypeExtensions.IsSum(this OpenTelemetry.Metrics.MetricType self) -> bool
 static OpenTelemetry.Sdk.CreateMeterProviderBuilder() -> OpenTelemetry.Metrics.MeterProviderBuilder
-static readonly OpenTelemetry.Metrics.MetricStreamConfiguration.Drop -> OpenTelemetry.Metrics.MetricStreamConfiguration
 virtual OpenTelemetry.BaseExporter<T>.OnForceFlush(int timeoutMilliseconds) -> bool
 virtual OpenTelemetry.Metrics.MetricReader.Dispose(bool disposing) -> void
 virtual OpenTelemetry.Metrics.MetricReader.OnCollect(int timeoutMilliseconds) -> bool
--- a/src/OpenTelemetry/Metrics/ExplicitBucketHistogramConfiguration.cs
+++ b/src/OpenTelemetry/Metrics/ExplicitBucketHistogramConfiguration.cs
@ -14,19 +14,78 @@
 // limitations under the License.
 // </copyright>

+using System;
+
 namespace OpenTelemetry.Metrics
 {
+    /// <summary>
+    /// Stores configuration for a histogram metric stream with explicit bucket boundaries.
+    /// </summary>
    public class ExplicitBucketHistogramConfiguration : MetricStreamConfiguration
    {
        /// <summary>
-        /// Gets or sets the values representing explicit histogram bucket
-        /// boundary values.
+        /// Gets or sets the optional boundaries of the histogram metric stream.
        /// </summary>
        /// <remarks>
-        /// The array must be in ascending order with distinct values.
-        /// An empty array would result in no histogram buckets being calculated.
-        /// A null value would result in default bucket boundaries being used.
+        /// Requirements:
+        /// <list type="bullet">
+        /// <item>The array must be in ascending order with distinct
+        /// values.</item>
+        /// <item>An empty array would result in no histogram buckets being
+        /// calculated.</item>
+        /// <item>A null value would result in default bucket boundaries being
+        /// used.</item>
+        /// </list>
+        /// Note: A copy is made of the provided array. Boundaries cannot be
+        /// modified after being set.
        /// </remarks>
-        public double[] Boundaries { get; set; }
+        public double[] Boundaries
+        {
+            get
+            {
+                if (this.CopiedBoundaries != null)
+                {
+                    double[] copy = new double[this.CopiedBoundaries.Length];
+                    this.CopiedBoundaries.AsSpan().CopyTo(copy);
+                    return copy;
+                }
+
+                return null;
+            }
+
+            set
+            {
+                if (value != null)
+                {
+                    if (!IsSortedAndDistinct(value))
+                    {
+                        throw new ArgumentException($"Histogram boundaries are invalid. Histogram boundaries must be in ascending order with distinct values.", nameof(value));
+                    }
+
+                    double[] copy = new double[value.Length];
+                    value.AsSpan().CopyTo(copy);
+                    this.CopiedBoundaries = copy;
+                }
+                else
+                {
+                    this.CopiedBoundaries = null;
+                }
+            }
+        }
+
+        internal double[] CopiedBoundaries { get; private set; }
+
+        private static bool IsSortedAndDistinct(double[] values)
+        {
+            for (int i = 1; i < values.Length; i++)
+            {
+                if (values[i] <= values[i - 1])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
    }
 }
--- a/src/OpenTelemetry/Metrics/MeterProviderBuilderBase.cs
+++ b/src/OpenTelemetry/Metrics/MeterProviderBuilderBase.cs
@ -81,7 +81,12 @@ namespace OpenTelemetry.Metrics

        internal MeterProviderBuilder AddView(string instrumentName, string name)
        {
-            return this.AddView(instrumentName, new MetricStreamConfiguration() { Name = name });
+            return this.AddView(
+                instrumentName,
+                new MetricStreamConfiguration
+                {
+                    Name = name,
+                });
        }

        internal MeterProviderBuilder AddView(string instrumentName, MetricStreamConfiguration metricStreamConfiguration)
--- a/src/OpenTelemetry/Metrics/MeterProviderBuilderExtensions.cs
+++ b/src/OpenTelemetry/Metrics/MeterProviderBuilderExtensions.cs
@ -16,6 +16,7 @@

 using System;
 using System.Diagnostics.Metrics;
+using OpenTelemetry.Internal;
 using OpenTelemetry.Resources;

 namespace OpenTelemetry.Metrics
@ -85,15 +86,7 @@ namespace OpenTelemetry.Metrics
        /// <remarks>See View specification here : https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#view.</remarks>
        public static MeterProviderBuilder AddView(this MeterProviderBuilder meterProviderBuilder, string instrumentName, MetricStreamConfiguration metricStreamConfiguration)
        {
-            if (metricStreamConfiguration == null)
-            {
-                throw new ArgumentNullException($"Metric stream configuration cannot be null.", nameof(metricStreamConfiguration));
-            }
-
-            if (!MeterProviderBuilderSdk.IsValidViewName(metricStreamConfiguration.Name))
-            {
-                throw new ArgumentException($"Custom view name {metricStreamConfiguration.Name} is invalid.", nameof(metricStreamConfiguration.Name));
-            }
+            Guard.ThrowIfNull(metricStreamConfiguration);

            if (metricStreamConfiguration.Name != null && instrumentName.IndexOf('*') != -1)
            {
@ -104,15 +97,6 @@ namespace OpenTelemetry.Metrics
                    nameof(instrumentName));
            }

-            if (metricStreamConfiguration is ExplicitBucketHistogramConfiguration histogramConfiguration)
-            {
-                // Validate histogram boundaries
-                if (histogramConfiguration.Boundaries != null && !IsSortedAndDistinct(histogramConfiguration.Boundaries))
-                {
-                    throw new ArgumentException($"Histogram boundaries must be in ascending order with distinct values", nameof(histogramConfiguration.Boundaries));
-                }
-            }
-
            if (meterProviderBuilder is MeterProviderBuilderBase meterProviderBuilderBase)
            {
                return meterProviderBuilderBase.AddView(instrumentName, metricStreamConfiguration);
@ -128,9 +112,19 @@ namespace OpenTelemetry.Metrics
        /// <param name="meterProviderBuilder"><see cref="MeterProviderBuilder"/>.</param>
        /// <param name="viewConfig">Function to configure aggregation based on the instrument.</param>
        /// <returns><see cref="MeterProvider"/>.</returns>
-        /// <remarks>See View specification here : https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#view.</remarks>
+        /// <remarks>
+        /// <list type="bullet">
+        /// <item>Note: An invalid <see cref="MetricStreamConfiguration"/>
+        /// returned from <paramref name="viewConfig"/> will cause a dropping
+        /// behavior for the instrument being configured, no error will be
+        /// thrown at runtime.</item>
+        /// <item>See View specification here : https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#view.</item>
+        /// </list>
+        /// </remarks>
        public static MeterProviderBuilder AddView(this MeterProviderBuilder meterProviderBuilder, Func<Instrument, MetricStreamConfiguration> viewConfig)
        {
+            Guard.ThrowIfNull(viewConfig);
+
            if (meterProviderBuilder is MeterProviderBuilderBase meterProviderBuilderBase)
            {
                return meterProviderBuilderBase.AddView(viewConfig);
@ -222,18 +216,5 @@ namespace OpenTelemetry.Metrics

            return null;
        }
-
-        private static bool IsSortedAndDistinct(double[] values)
-        {
-            for (int i = 1; i < values.Length; i++)
-            {
-                if (values[i] <= values[i - 1])
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
    }
 }
--- a/src/OpenTelemetry/Metrics/MetricReaderExt.cs
+++ b/src/OpenTelemetry/Metrics/MetricReaderExt.cs
@ -133,7 +133,7 @@ namespace OpenTelemetry.Metrics
                            "Either change the name of the instrument or use MeterProviderBuilder.AddView to resolve the conflict.");
                    }

-                    if (metricStreamConfig?.Aggregation == Aggregation.Drop)
+                    if (metricStreamConfig == MetricStreamConfiguration.Drop)
                    {
                        OpenTelemetrySdkEventSource.Log.MetricInstrumentIgnored(metricName, instrument.Meter.Name, "View configuration asks to drop this instrument.", "Modify view configuration to allow this instrument, if desired.");
                        continue;
@ -147,9 +147,9 @@ namespace OpenTelemetry.Metrics
                    else
                    {
                        Metric metric;
-                        string[] tagKeysInteresting = metricStreamConfig?.TagKeys;
+                        string[] tagKeysInteresting = metricStreamConfig?.CopiedTagKeys;
                        double[] histogramBucketBounds = (metricStreamConfig is ExplicitBucketHistogramConfiguration histogramConfig
-                            && histogramConfig.Boundaries != null) ? histogramConfig.Boundaries : null;
+                            && histogramConfig.CopiedBoundaries != null) ? histogramConfig.CopiedBoundaries : null;
                        metric = new Metric(instrumentIdentity, this.Temporality, this.maxMetricPointsPerMetricStream, histogramBucketBounds, tagKeysInteresting);

                        this.instrumentIdentityToMetric[instrumentIdentity] = metric;
--- a/src/OpenTelemetry/Metrics/MetricStreamConfiguration.cs
+++ b/src/OpenTelemetry/Metrics/MetricStreamConfiguration.cs
@ -14,46 +14,99 @@
 // limitations under the License.
 // </copyright>

+using System;
+
 namespace OpenTelemetry.Metrics
 {
-    // TODO: can be optimized like MetricType
-    internal enum Aggregation
-    {
-#pragma warning disable SA1602 // Enumeration items should be documented
-        Default,
-        Drop,
-        Sum,
-        LastValue,
-        Histogram,
-#pragma warning restore SA1602 // Enumeration items should be documented
-    }
-
    /// <summary>
-    /// Holds the configuration for a MetricStream.
+    /// Stores configuration for a MetricStream.
    /// </summary>
    public class MetricStreamConfiguration
    {
-        public static readonly MetricStreamConfiguration Drop = new DropConfiguration();
+        private string name;

-        public string Name { get; set; }
+        /// <summary>
+        /// Gets the drop configuration.
+        /// </summary>
+        /// <remarks>
+        /// Note: All metrics for the given instrument will be dropped (not
+        /// collected).
+        /// </remarks>
+        public static MetricStreamConfiguration Drop { get; } = new MetricStreamConfiguration();

+        /// <summary>
+        /// Gets or sets the optional name of the metric stream.
+        /// </summary>
+        /// <remarks>
+        /// Note: If not provided the instrument name will be used.
+        /// </remarks>
+        public string Name
+        {
+            get => this.name;
+            set
+            {
+                if (value != null && !MeterProviderBuilderSdk.IsValidViewName(value))
+                {
+                    throw new ArgumentException($"Custom view name {value} is invalid.", nameof(value));
+                }
+
+                this.name = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the optional description of the metric stream.
+        /// </summary>
+        /// <remarks>
+        /// Note: If not provided the instrument description will be used.
+        /// </remarks>
        public string Description { get; set; }

-        public string[] TagKeys { get; set; }
+        /// <summary>
+        /// Gets or sets the optional tag keys to include in the metric stream.
+        /// </summary>
+        /// <remarks>
+        /// Notes:
+        /// <list type="bullet">
+        /// <item>If provided any metrics for the instrument which do not match
+        /// all the tag keys will be dropped (not collected).</item>
+        /// <item>A copy is made of the provided array. TagKeys cannot be
+        /// modified after being set.</item>
+        /// </list>
+        /// </remarks>
+        public string[] TagKeys
+        {
+            get
+            {
+                if (this.CopiedTagKeys != null)
+                {
+                    string[] copy = new string[this.CopiedTagKeys.Length];
+                    this.CopiedTagKeys.AsSpan().CopyTo(copy);
+                    return copy;
+                }

-        internal virtual Aggregation Aggregation { get; set; }
+                return null;
+            }
+
+            set
+            {
+                if (value != null)
+                {
+                    string[] copy = new string[value.Length];
+                    value.AsSpan().CopyTo(copy);
+                    this.CopiedTagKeys = copy;
+                }
+                else
+                {
+                    this.CopiedTagKeys = null;
+                }
+            }
+        }
+
+        internal string[] CopiedTagKeys { get; private set; }

        // TODO: MetricPoints caps can be configured here on
        // a per stream basis, when we add such a capability
        // in the future.
-
-        private sealed class DropConfiguration : MetricStreamConfiguration
-        {
-            internal override Aggregation Aggregation
-            {
-                get => Aggregation.Drop;
-                set { }
-            }
-        }
    }
 }
--- a/test/OpenTelemetry.Tests/Metrics/MetricAPITest.cs
+++ b/test/OpenTelemetry.Tests/Metrics/MetricAPITest.cs
@ -371,8 +371,8 @@ namespace OpenTelemetry.Metrics.Tests
            using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
            var meterProviderBuilder = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
-                .AddView("instrumentName", new MetricStreamConfiguration { Description = "newDescription1" })
-                .AddView("instrumentName", new MetricStreamConfiguration { Description = "newDescription2" })
+                .AddView("instrumentName", new MetricStreamConfiguration() { Description = "newDescription1" })
+                .AddView("instrumentName", new MetricStreamConfiguration() { Description = "newDescription2" })
                .AddInMemoryExporter(exportedItems);

            using var meterProvider = meterProviderBuilder.Build();
@ -420,13 +420,13 @@ namespace OpenTelemetry.Metrics.Tests
                .AddMeter(meter.Name)
                .AddView((instrument) =>
                {
-                    return new MetricStreamConfiguration { Name = "MetricStreamA", Description = "description" };
+                    return new MetricStreamConfiguration() { Name = "MetricStreamA", Description = "description" };
                })
                .AddView((instrument) =>
                {
                    return instrument.Description == "description1"
-                        ? new MetricStreamConfiguration { Name = "MetricStreamB" }
-                        : new MetricStreamConfiguration { Name = "MetricStreamC" };
+                        ? new MetricStreamConfiguration() { Name = "MetricStreamB" }
+                        : new MetricStreamConfiguration() { Name = "MetricStreamC" };
                })
                .AddInMemoryExporter(exportedItems);

@ -866,7 +866,7 @@ namespace OpenTelemetry.Metrics.Tests
                {
                    metricReaderOptions.Temporality = exportDelta ? AggregationTemporality.Delta : AggregationTemporality.Cumulative;
                })
-                .AddView("requestCount", new MetricStreamConfiguration() { TagKeys = new string[] { } })
+                .AddView("requestCount", new MetricStreamConfiguration() { TagKeys = Array.Empty<string>() })
                .Build();

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
--- a/test/OpenTelemetry.Tests/Metrics/MetricViewTests.cs
+++ b/test/OpenTelemetry.Tests/Metrics/MetricViewTests.cs
@ -19,19 +19,12 @@ using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using OpenTelemetry.Tests;
 using Xunit;
-using Xunit.Abstractions;

 namespace OpenTelemetry.Metrics.Tests
 {
    public class MetricViewTests
    {
        private const int MaxTimeToAllowForFlush = 10000;
-        private readonly ITestOutputHelper output;
-
-        public MetricViewTests(ITestOutputHelper output)
-        {
-            this.output = output;
-        }

        [Fact]
        public void ViewToRenameMetric()
@ -71,7 +64,7 @@ namespace OpenTelemetry.Metrics.Tests

            ex = Assert.Throws<ArgumentException>(() => Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter1.Name)
-                .AddView("name1", new MetricStreamConfiguration { Name = viewNewName })
+                .AddView("name1", new MetricStreamConfiguration() { Name = viewNewName })
                .AddInMemoryExporter(exportedItems)
                .Build());

@ -130,6 +123,34 @@ namespace OpenTelemetry.Metrics.Tests
            Assert.Contains("Histogram boundaries must be in ascending order with distinct values", ex.Message);
        }

+        [Theory]
+        [MemberData(nameof(MetricTestData.InvalidHistogramBoundaries), MemberType = typeof(MetricTestData))]
+        public void AddViewWithInvalidHistogramBoundsIgnored(double[] boundaries)
+        {
+            var exportedItems = new List<Metric>();
+
+            using var meter1 = new Meter("AddViewWithInvalidHistogramBoundsIgnored");
+
+            var counter1 = meter1.CreateCounter<long>("counter1");
+
+            using (var provider = Sdk.CreateMeterProviderBuilder()
+                .AddMeter(meter1.Name)
+                .AddView((instrument) =>
+                {
+                    return instrument.Name == counter1.Name
+                        ? new ExplicitBucketHistogramConfiguration() { Boundaries = boundaries }
+                        : null;
+                })
+                .AddInMemoryExporter(exportedItems)
+                .Build())
+            {
+                counter1.Add(1);
+            }
+
+            // Counter is ignored due to invalid histogram bounds.
+            Assert.Empty(exportedItems);
+        }
+
        [Theory]
        [MemberData(nameof(MetricTestData.ValidInstrumentNames), MemberType = typeof(MetricTestData))]
        public void ViewWithValidNameExported(string viewNewName)
@ -443,11 +464,20 @@ namespace OpenTelemetry.Metrics.Tests
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("FruitCounter", new MetricStreamConfiguration()
-                { TagKeys = new string[] { "name" }, Name = "NameOnly" })
+                {
+                    TagKeys = new string[] { "name" },
+                    Name = "NameOnly",
+                })
                .AddView("FruitCounter", new MetricStreamConfiguration()
-                { TagKeys = new string[] { "size" }, Name = "SizeOnly" })
+                {
+                    TagKeys = new string[] { "size" },
+                    Name = "SizeOnly",
+                })
                .AddView("FruitCounter", new MetricStreamConfiguration()
-                { TagKeys = new string[] { }, Name = "NoTags" })
+                {
+                    TagKeys = Array.Empty<string>(),
+                    Name = "NoTags",
+                })
                .AddInMemoryExporter(exportedItems)
                .Build();

@ -504,7 +534,7 @@ namespace OpenTelemetry.Metrics.Tests
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
-                .AddView("counterNotInteresting", new MetricStreamConfiguration() { Aggregation = Aggregation.Drop })
+                .AddView("counterNotInteresting", MetricStreamConfiguration.Drop)
                .AddInMemoryExporter(exportedItems)
                .Build();

@ -527,7 +557,7 @@ namespace OpenTelemetry.Metrics.Tests
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
-                .AddView("observableCounterNotInteresting", new MetricStreamConfiguration() { Aggregation = Aggregation.Drop })
+                .AddView("observableCounterNotInteresting", MetricStreamConfiguration.Drop)
                .AddInMemoryExporter(exportedItems)
                .Build();

@ -548,7 +578,7 @@ namespace OpenTelemetry.Metrics.Tests
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
-                .AddView("observableGaugeNotInteresting", new MetricStreamConfiguration() { Aggregation = Aggregation.Drop })
+                .AddView("observableGaugeNotInteresting", MetricStreamConfiguration.Drop)
                .AddInMemoryExporter(exportedItems)
                .Build();

@ -569,7 +599,7 @@ namespace OpenTelemetry.Metrics.Tests
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
-                .AddView("server*", new MetricStreamConfiguration() { Aggregation = Aggregation.Drop })
+                .AddView("server*", MetricStreamConfiguration.Drop)
                .AddInMemoryExporter(exportedItems)
                .Build();

@ -612,12 +642,5 @@ namespace OpenTelemetry.Metrics.Tests
            Assert.Single(exportedItems);
            Assert.Equal("server.request_renamed", exportedItems[0].Name);
        }
-
-        [Fact]
-        public void MetricStreamConfigurationForDropMustNotAllowOverriding()
-        {
-            MetricStreamConfiguration.Drop.Aggregation = Aggregation.Histogram;
-            Assert.Equal(Aggregation.Drop, MetricStreamConfiguration.Drop.Aggregation);
-        }
    }
 }