Allow ability to override max Metric streams and MetricPoints per stream

src/OpenTelemetry/Metrics/AggregatorStore.cs

@@ -24,7 +24,6 @@ namespace OpenTelemetry.Metrics
 {
     internal sealed class AggregatorStore
     {
-        internal const int MaxMetricPoints = 2000;
         private static readonly ObjectArrayEqualityComparer ObjectArrayComparer = new ObjectArrayEqualityComparer();
         private readonly object lockZeroTags = new object();
         private readonly HashSet<string> tagKeysInteresting;
@@ -42,6 +41,7 @@ internal sealed class AggregatorStore
         private readonly double[] histogramBounds;
         private readonly UpdateLongDelegate updateLongCallback;
         private readonly UpdateDoubleDelegate updateDoubleCallback;
+        private readonly int metricPointLimit;
         private int metricPointIndex = 0;
         private int batchSize = 0;
         private bool zeroTagMetricPointInitialized;
@@ -51,11 +51,13 @@ internal sealed class AggregatorStore
         internal AggregatorStore(
             AggregationType aggType,
             AggregationTemporality temporality,
+            int metricPointLimit,
             double[] histogramBounds,
             string[] tagKeysInteresting = null)
         {
-            this.metricPoints = new MetricPoint[MaxMetricPoints];
-            this.currentMetricPointBatch = new int[MaxMetricPoints];
+            this.metricPointLimit = metricPointLimit;
+            this.metricPoints = new MetricPoint[metricPointLimit];
+            this.currentMetricPointBatch = new int[metricPointLimit];
             this.aggType = aggType;
             this.temporality = temporality;
             this.outputDelta = temporality == AggregationTemporality.Delta ? true : false;
@@ -98,7 +100,7 @@ internal void Update(double value, ReadOnlySpan<KeyValuePair<string, object>> ta
         internal int Snapshot()
         {
             this.batchSize = 0;
-            var indexSnapshot = Math.Min(this.metricPointIndex, MaxMetricPoints - 1);
+            var indexSnapshot = Math.Min(this.metricPointIndex, this.metricPointLimit - 1);
             if (this.temporality == AggregationTemporality.Delta)
             {
                 this.SnapshotDelta(indexSnapshot);
@@ -197,7 +199,7 @@ private int LookupAggregatorStore(string[] tagKeys, object[] tagValues, int leng
             if (!value2metrics.TryGetValue(tagValues, out aggregatorIndex))
             {
                 aggregatorIndex = this.metricPointIndex;
-                if (aggregatorIndex >= MaxMetricPoints)
+                if (aggregatorIndex >= this.metricPointLimit)
                 {
                     // sorry! out of data points.
                     // TODO: Once we support cleanup of
@@ -212,7 +214,7 @@ private int LookupAggregatorStore(string[] tagKeys, object[] tagValues, int leng
                     if (!value2metrics.TryGetValue(tagValues, out aggregatorIndex))
                     {
                         aggregatorIndex = Interlocked.Increment(ref this.metricPointIndex);
-                        if (aggregatorIndex >= MaxMetricPoints)
+                        if (aggregatorIndex >= this.metricPointLimit)
                         {
                             // sorry! out of data points.
                             // TODO: Once we support cleanup of

src/OpenTelemetry/Metrics/MeterProviderBuilderBase.cs

@@ -29,10 +29,14 @@ namespace OpenTelemetry.Metrics
     /// </summary>
     public abstract class MeterProviderBuilderBase : MeterProviderBuilder
     {
+        internal const int MaxMetrics = 1000;
+        internal const int MaxMetricPointsPerMetric = 2000;
         private readonly List<InstrumentationFactory> instrumentationFactories = new List<InstrumentationFactory>();
         private readonly List<string> meterSources = new List<string>();
         private readonly List<Func<Instrument, MetricStreamConfiguration>> viewConfigs = new List<Func<Instrument, MetricStreamConfiguration>>();
         private ResourceBuilder resourceBuilder = ResourceBuilder.CreateDefault();
+        private int metricStreamLimit = MaxMetrics;
+        private int metricPointLimit = MaxMetricPointsPerMetric;
 
         protected MeterProviderBuilderBase()
         {
@@ -105,6 +109,22 @@ internal MeterProviderBuilder AddView(Func<Instrument, MetricStreamConfiguration
             return this;
         }
 
+        internal MeterProviderBuilder SetMetricStreamLimit(int metricStreamLimit)
+        {
+            Guard.Range(metricStreamLimit, min: 1);
+
+            this.metricStreamLimit = metricStreamLimit;
+            return this;
+        }
+
+        internal MeterProviderBuilder SetMetricPointPerMetricStreamLimit(int metricPointLimit)
+        {
+            Guard.Range(metricPointLimit, min: 1);
+
+            this.metricPointLimit = metricPointLimit;
+            return this;
+        }
+
         internal MeterProviderBuilder SetResourceBuilder(ResourceBuilder resourceBuilder)
         {
             Debug.Assert(resourceBuilder != null, $"{nameof(resourceBuilder)} must not be null");
@@ -124,6 +144,8 @@ protected MeterProvider Build()
                 this.meterSources,
                 this.instrumentationFactories,
                 this.viewConfigs,
+                this.metricStreamLimit,
+                this.metricPointLimit,
                 this.MetricReaders.ToArray());
         }
 

src/OpenTelemetry/Metrics/MeterProviderBuilderExtensions.cs

@@ -121,6 +121,53 @@ public static MeterProviderBuilder AddView(this MeterProviderBuilder meterProvid
             return meterProviderBuilder;
         }
 
+        /// <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,
+        /// so this control the numbers of instruments supported.
+        /// When Views are configued, a single instrument can result in multiple metric stream,
+        /// so this controls the number of streams.
+        /// </summary>
+        /// <param name="meterProviderBuilder">MeterProviderBuilder instance.</param>
+        /// <param name="metricStreamLimit">The number of metric streams allowed.</param>
+        /// <returns>Returns <see cref="MeterProviderBuilder"/> for chaining.</returns>
+        /// <remarks>
+        /// If an instrument is created, but disposed later, this will still be contributing to the limit.
+        /// This may change in the future.
+        /// </remarks>
+        public static MeterProviderBuilder SetMetricStreamLimit(this MeterProviderBuilder meterProviderBuilder, int metricStreamLimit)
+        {
+            if (meterProviderBuilder is MeterProviderBuilderBase meterProviderBuilderBase)
+            {
+                meterProviderBuilderBase.SetMetricStreamLimit(metricStreamLimit);
+            }
+
+            return meterProviderBuilder;
+        }
+
+        /// <summary>
+        /// Sets the maximum number of MetricPoints allowed per metric stream.
+        /// This limis the number of unique combination of key value pairs used
+        /// for reporting measurement.
+        /// </summary>
+        /// <param name="meterProviderBuilder">MeterProviderBuilder instance.</param>
+        /// <param name="metricPointLimit">The maximum number of metric points allowed per metric stream.</param>
+        /// <returns>Returns <see cref="MeterProviderBuilder"/> for chaining.</returns>
+        /// <remarks>
+        /// If a particular combination of key value pair is used atleast once,
+        /// it will still be contributing to the limit.
+        /// This may change in the future.
+        /// </remarks>
+        public static MeterProviderBuilder SetMetricPointPerMetricStreamLimit(this MeterProviderBuilder meterProviderBuilder, int metricPointLimit)
+        {
+            if (meterProviderBuilder is MeterProviderBuilderBase meterProviderBuilderBase)
+            {
+                meterProviderBuilderBase.SetMetricPointPerMetricStreamLimit(metricPointLimit);
+            }
+
+            return meterProviderBuilder;
+        }
+
         /// <summary>
         /// Sets the <see cref="ResourceBuilder"/> from which the Resource associated with
         /// this provider is built from. Overwrites currently set ResourceBuilder.

src/OpenTelemetry/Metrics/MeterProviderSdk.cs

@@ -27,7 +27,6 @@ namespace OpenTelemetry.Metrics
 {
     internal sealed class MeterProviderSdk : MeterProvider
     {
-        internal const int MaxMetrics = 1000;
         internal int ShutdownCount;
         private readonly Metric[] metrics;
         private readonly Metric[] metricsCurrentBatch;
@@ -38,6 +37,8 @@ internal sealed class MeterProviderSdk : MeterProvider
         private readonly HashSet<string> metricStreamNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
         private readonly MeterListener listener;
         private readonly MetricReader reader;
+        private readonly int metricStreamLimit;
+        private readonly int metricPointLimit;
         private int metricIndex = -1;
         private bool disposed;
 
@@ -46,12 +47,16 @@ internal sealed class MeterProviderSdk : MeterProvider
             IEnumerable<string> meterSources,
             List<MeterProviderBuilderBase.InstrumentationFactory> instrumentationFactories,
             List<Func<Instrument, MetricStreamConfiguration>> viewConfigs,
+            int metricStreamLimit,
+            int metricPointLimit,
             IEnumerable<MetricReader> readers)
         {
             this.Resource = resource;
             this.viewConfigs = viewConfigs;
-            this.metrics = new Metric[MaxMetrics];
-            this.metricsCurrentBatch = new Metric[MaxMetrics];
+            this.metrics = new Metric[metricStreamLimit];
+            this.metricsCurrentBatch = new Metric[metricStreamLimit];
+            this.metricStreamLimit = metricStreamLimit;
+            this.metricPointLimit = metricPointLimit;
 
             AggregationTemporality temporality = AggregationTemporality.Cumulative;
 
@@ -183,7 +188,7 @@ internal sealed class MeterProviderSdk : MeterProvider
                             }
 
                             var index = ++this.metricIndex;
-                            if (index >= MaxMetrics)
+                            if (index >= this.metricStreamLimit)
                             {
                                 // TODO: Log that instrument is ignored
                                 // as max number of Metrics have reached.
@@ -195,7 +200,7 @@ internal sealed class MeterProviderSdk : MeterProvider
                                 string[] tagKeysInteresting = metricStreamConfig?.TagKeys;
                                 double[] histogramBucketBounds = (metricStreamConfig is HistogramConfiguration histogramConfig
                                     && histogramConfig.BucketBounds != null) ? histogramConfig.BucketBounds : null;
-                                metric = new Metric(instrument, temporality, metricStreamName, metricDescription, histogramBucketBounds, tagKeysInteresting);
+                                metric = new Metric(instrument, temporality, metricStreamName, metricDescription, this.metricPointLimit, histogramBucketBounds, tagKeysInteresting);
 
                                 this.metrics[index] = metric;
                                 metrics.Add(metric);
@@ -256,14 +261,14 @@ internal sealed class MeterProviderSdk : MeterProvider
                             }
 
                             var index = ++this.metricIndex;
-                            if (index >= MaxMetrics)
+                            if (index >= this.metricStreamLimit)
                             {
                                 OpenTelemetrySdkEventSource.Log.MetricInstrumentIgnored(metricName, instrument.Meter.Name, "Maximum allowed Metrics for the provider exceeded.", "Use views to drop unused instruments. Or configure Provider to allow higher limit.");
                                 return;
                             }
                             else
                             {
-                                metric = new Metric(instrument, temporality, metricName, instrument.Description);
+                                metric = new Metric(instrument, temporality, metricName, instrument.Description, this.metricPointLimit);
                                 this.metrics[index] = metric;
                                 this.metricStreamNames.Add(metricName);
                             }
@@ -437,7 +442,7 @@ internal Batch<Metric> Collect()
                         OpenTelemetrySdkEventSource.Log.MetricObserverCallbackException(exception);
                     }
 
-                    var indexSnapshot = Math.Min(this.metricIndex, MaxMetrics - 1);
+                    var indexSnapshot = Math.Min(this.metricIndex, this.metricStreamLimit - 1);
                     var target = indexSnapshot + 1;
                     int metricCountCurrentBatch = 0;
                     for (int i = 0; i < target; i++)

src/OpenTelemetry/Metrics/Metric.cs

@@ -30,6 +30,7 @@ public sealed class Metric
             AggregationTemporality temporality,
             string metricName,
             string metricDescription,
+            int metricPointLimit,
             double[] histogramBounds = null,
             string[] tagKeysInteresting = null)
         {
@@ -104,7 +105,7 @@ public sealed class Metric
                 // TODO: Log and assign some invalid Enum.
             }
 
-            this.aggStore = new AggregatorStore(aggType, temporality, histogramBounds ?? DefaultHistogramBounds, tagKeysInteresting);
+            this.aggStore = new AggregatorStore(aggType, temporality, metricPointLimit, histogramBounds ?? DefaultHistogramBounds, tagKeysInteresting);
             this.Temporality = temporality;
             this.InstrumentDisposed = false;
         }

test/OpenTelemetry.Tests/Metrics/MetricAPITest.cs

@@ -449,26 +449,26 @@ int MetricPointCount()
             // for no tag point!
             // This may be changed later.
             counterLong.Add(10);
-            for (int i = 0; i < AggregatorStore.MaxMetricPoints + 1; i++)
+            for (int i = 0; i < MeterProviderBuilderBase.MaxMetricPointsPerMetric + 1; i++)
             {
                 counterLong.Add(10, new KeyValuePair<string, object>("key", "value" + i));
             }
 
             metricReader.Collect();
-            Assert.Equal(AggregatorStore.MaxMetricPoints, MetricPointCount());
+            Assert.Equal(MeterProviderBuilderBase.MaxMetricPointsPerMetric, MetricPointCount());
 
             metricItems.Clear();
             counterLong.Add(10);
-            for (int i = 0; i < AggregatorStore.MaxMetricPoints + 1; i++)
+            for (int i = 0; i < MeterProviderBuilderBase.MaxMetricPointsPerMetric + 1; i++)
             {
                 counterLong.Add(10, new KeyValuePair<string, object>("key", "value" + i));
             }
 
             metricReader.Collect();
-            Assert.Equal(AggregatorStore.MaxMetricPoints, MetricPointCount());
+            Assert.Equal(MeterProviderBuilderBase.MaxMetricPointsPerMetric, MetricPointCount());
 
             counterLong.Add(10);
-            for (int i = 0; i < AggregatorStore.MaxMetricPoints + 1; i++)
+            for (int i = 0; i < MeterProviderBuilderBase.MaxMetricPointsPerMetric + 1; i++)
             {
                 counterLong.Add(10, new KeyValuePair<string, object>("key", "value" + i));
             }
@@ -479,7 +479,7 @@ int MetricPointCount()
             counterLong.Add(10, new KeyValuePair<string, object>("key", "valueC"));
             metricItems.Clear();
             metricReader.Collect();
-            Assert.Equal(AggregatorStore.MaxMetricPoints, MetricPointCount());
+            Assert.Equal(MeterProviderBuilderBase.MaxMetricPointsPerMetric, MetricPointCount());
         }
 
         [Fact]