[DRAFT] fixing InMemoryExporter & Metrics bug. new class: ExportableMetricCopy. new ctor: InMemoryExporter(Func)

src/OpenTelemetry.Exporter.InMemory/.publicApi/net462/PublicAPI.Unshipped.txt

@@ -1,3 +1,15 @@
+OpenTelemetry.Exporter.InMemoryExporter<T>.InMemoryExporter(System.Func<OpenTelemetry.Batch<T>, OpenTelemetry.ExportResult> exportFunc) -> void
+OpenTelemetry.Metrics.ExportableMetricCopy
+OpenTelemetry.Metrics.ExportableMetricCopy.Description.get -> string
+OpenTelemetry.Metrics.ExportableMetricCopy.ExportableMetricCopy(OpenTelemetry.Metrics.Metric metric) -> void
+OpenTelemetry.Metrics.ExportableMetricCopy.MeterName.get -> string
+OpenTelemetry.Metrics.ExportableMetricCopy.MeterVersion.get -> string
+OpenTelemetry.Metrics.ExportableMetricCopy.MetricPoints.get -> System.Collections.Generic.IReadOnlyList<OpenTelemetry.Metrics.MetricPoint>
+OpenTelemetry.Metrics.ExportableMetricCopy.MetricType.get -> OpenTelemetry.Metrics.MetricType
+OpenTelemetry.Metrics.ExportableMetricCopy.Name.get -> string
+OpenTelemetry.Metrics.ExportableMetricCopy.Unit.get -> string
 OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions
-static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Collections.Generic.ICollection<OpenTelemetry.Metrics.Metric> exportedItems) -> OpenTelemetry.Metrics.MeterProviderBuilder
-static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Collections.Generic.ICollection<OpenTelemetry.Metrics.Metric> exportedItems, System.Action<OpenTelemetry.Metrics.MetricReaderOptions> configureMetricReader) -> OpenTelemetry.Metrics.MeterProviderBuilder
+static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Collections.Generic.ICollection<OpenTelemetry.Metrics.ExportableMetricCopy> exportedItems) -> OpenTelemetry.Metrics.MeterProviderBuilder
+static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Collections.Generic.ICollection<OpenTelemetry.Metrics.ExportableMetricCopy> exportedItems, System.Action<OpenTelemetry.Metrics.MetricReaderOptions> configureMetricReader) -> OpenTelemetry.Metrics.MeterProviderBuilder
+static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Func<OpenTelemetry.Batch<OpenTelemetry.Metrics.Metric>, OpenTelemetry.ExportResult> exportFunc) -> OpenTelemetry.Metrics.MeterProviderBuilder
+static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Func<OpenTelemetry.Batch<OpenTelemetry.Metrics.Metric>, OpenTelemetry.ExportResult> exportFunc, System.Action<OpenTelemetry.Metrics.MetricReaderOptions> configureMetricReader) -> OpenTelemetry.Metrics.MeterProviderBuilder

src/OpenTelemetry.Exporter.InMemory/.publicApi/netstandard2.0/PublicAPI.Unshipped.txt

@@ -1,3 +1,15 @@
+OpenTelemetry.Exporter.InMemoryExporter<T>.InMemoryExporter(System.Func<OpenTelemetry.Batch<T>, OpenTelemetry.ExportResult> exportFunc) -> void
+OpenTelemetry.Metrics.ExportableMetricCopy
+OpenTelemetry.Metrics.ExportableMetricCopy.Description.get -> string
+OpenTelemetry.Metrics.ExportableMetricCopy.ExportableMetricCopy(OpenTelemetry.Metrics.Metric metric) -> void
+OpenTelemetry.Metrics.ExportableMetricCopy.MeterName.get -> string
+OpenTelemetry.Metrics.ExportableMetricCopy.MeterVersion.get -> string
+OpenTelemetry.Metrics.ExportableMetricCopy.MetricPoints.get -> System.Collections.Generic.IReadOnlyList<OpenTelemetry.Metrics.MetricPoint>
+OpenTelemetry.Metrics.ExportableMetricCopy.MetricType.get -> OpenTelemetry.Metrics.MetricType
+OpenTelemetry.Metrics.ExportableMetricCopy.Name.get -> string
+OpenTelemetry.Metrics.ExportableMetricCopy.Unit.get -> string
 OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions
-static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Collections.Generic.ICollection<OpenTelemetry.Metrics.Metric> exportedItems) -> OpenTelemetry.Metrics.MeterProviderBuilder
-static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Collections.Generic.ICollection<OpenTelemetry.Metrics.Metric> exportedItems, System.Action<OpenTelemetry.Metrics.MetricReaderOptions> configureMetricReader) -> OpenTelemetry.Metrics.MeterProviderBuilder
+static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Collections.Generic.ICollection<OpenTelemetry.Metrics.ExportableMetricCopy> exportedItems) -> OpenTelemetry.Metrics.MeterProviderBuilder
+static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Collections.Generic.ICollection<OpenTelemetry.Metrics.ExportableMetricCopy> exportedItems, System.Action<OpenTelemetry.Metrics.MetricReaderOptions> configureMetricReader) -> OpenTelemetry.Metrics.MeterProviderBuilder
+static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Func<OpenTelemetry.Batch<OpenTelemetry.Metrics.Metric>, OpenTelemetry.ExportResult> exportFunc) -> OpenTelemetry.Metrics.MeterProviderBuilder
+static OpenTelemetry.Metrics.InMemoryExporterMetricsExtensions.AddInMemoryExporter(this OpenTelemetry.Metrics.MeterProviderBuilder builder, System.Func<OpenTelemetry.Batch<OpenTelemetry.Metrics.Metric>, OpenTelemetry.ExportResult> exportFunc, System.Action<OpenTelemetry.Metrics.MetricReaderOptions> configureMetricReader) -> OpenTelemetry.Metrics.MeterProviderBuilder

src/OpenTelemetry.Exporter.InMemory/ExportableMetricCopy.cs

@@ -0,0 +1,58 @@
+// <copyright file="ExportableMetricCopy.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System.Collections.Generic;
+
+namespace OpenTelemetry.Metrics
+{
+    /// <summary>
+    /// This class represents a selective copy of <see cref="Metric"/>.
+    /// This contains the minimum fields and properties needed for most
+    /// unit testing scenarios.
+    /// </summary>
+    public class ExportableMetricCopy
+    {
+        private readonly MetricStreamIdentity instrumentIdentity;
+
+        public ExportableMetricCopy(Metric metric)
+        {
+            this.instrumentIdentity = metric.InstrumentIdentity;
+            this.MetricType = metric.MetricType;
+
+            List<MetricPoint> metricPoints = new();
+            foreach (ref readonly var metricPoint in metric.GetMetricPoints())
+            {
+                metricPoints.Add(metricPoint.Copy());
+            }
+
+            this.MetricPoints = metricPoints;
+        }
+
+        public string Name => this.instrumentIdentity.InstrumentName;
+
+        public string Description => this.instrumentIdentity.Description;
+
+        public string Unit => this.instrumentIdentity.Unit;
+
+        public string MeterName => this.instrumentIdentity.MeterName;
+
+        public MetricType MetricType { get; }
+
+        public string MeterVersion => this.instrumentIdentity.MeterVersion;
+
+        public IReadOnlyList<MetricPoint> MetricPoints { get; }
+    }
+}

src/OpenTelemetry.Exporter.InMemory/InMemoryExporter.cs

@@ -14,6 +14,7 @@
 // limitations under the License.
 // </copyright>
 
+using System;
 using System.Collections.Generic;
 
 namespace OpenTelemetry.Exporter
@@ -22,13 +23,29 @@ public class InMemoryExporter<T> : BaseExporter<T>
         where T : class
     {
         private readonly ICollection<T> exportedItems;
+        private readonly ExportDelegate onExport;
 
         public InMemoryExporter(ICollection<T> exportedItems)
         {
+            if (typeof(T) == typeof(Metrics.Metric))
+            {
+                throw new NotSupportedException("Exported Metrics are not trustworthy because they can continue to be updated after export. Recommend use ExportableMetricCopy.");
+            }
+
             this.exportedItems = exportedItems;
+            this.onExport = this.DefaultExport;
+        }
+
+        public InMemoryExporter(Func<Batch<T>, ExportResult> exportFunc)
+        {
+            this.onExport = (in Batch<T> batch) => exportFunc(batch);
         }
 
-        public override ExportResult Export(in Batch<T> batch)
+        private delegate ExportResult ExportDelegate(in Batch<T> batch);
+
+        public override ExportResult Export(in Batch<T> batch) => this.onExport(batch);
+
+        private ExportResult DefaultExport(in Batch<T> batch)
         {
             if (this.exportedItems == null)
             {

src/OpenTelemetry.Exporter.InMemory/InMemoryExporterMetricsExtensions.cs

@@ -34,9 +34,39 @@ public static class InMemoryExporterMetricsExtensions
         /// Adds InMemory metric exporter to the <see cref="MeterProviderBuilder"/> using default options.
         /// </summary>
         /// <param name="builder"><see cref="MeterProviderBuilder"/> builder to use.</param>
-        /// <param name="exportedItems">Collection which will be populated with the exported MetricItem.</param>
+        /// <param name="exportedItems">Collection which will be populated with the exported MetricItem represented as <see cref="ExportableMetricCopy"/>.</param>
         /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
-        public static MeterProviderBuilder AddInMemoryExporter(this MeterProviderBuilder builder, ICollection<Metric> exportedItems)
+        public static MeterProviderBuilder AddInMemoryExporter(
+            this MeterProviderBuilder builder,
+            ICollection<ExportableMetricCopy> exportedItems)
+        {
+            return builder.AddInMemoryExporter(exportedItems: exportedItems, configureMetricReader: null);
+        }
+
+        /// <summary>
+        /// Adds InMemory metric exporter to the <see cref="MeterProviderBuilder"/> using default options.
+        /// </summary>
+        /// <param name="builder"><see cref="MeterProviderBuilder"/> builder to use.</param>
+        /// <param name="exportFunc">A function which will replace <see cref="InMemoryExporter{T}.Export(in Batch{T})"/>.</param>
+        /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
+        public static MeterProviderBuilder AddInMemoryExporter(
+            this MeterProviderBuilder builder,
+            Func<Batch<Metric>, ExportResult> exportFunc)
+        {
+            return builder.AddInMemoryExporter(exportFunc: exportFunc, configureMetricReader: null);
+        }
+
+        /// <summary>
+        /// Adds InMemory metric exporter to the <see cref="MeterProviderBuilder"/> using default options.
+        /// </summary>
+        /// <param name="builder"><see cref="MeterProviderBuilder"/> builder to use.</param>
+        /// <param name="exportedItems">Collection which will be populated with the exported MetricItem represented as <see cref="ExportableMetricCopy"/>.</param>
+        /// <param name="configureMetricReader"><see cref="MetricReader"/> configuration options.</param>
+        /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
+        public static MeterProviderBuilder AddInMemoryExporter(
+            this MeterProviderBuilder builder,
+            ICollection<ExportableMetricCopy> exportedItems,
+            Action<MetricReaderOptions> configureMetricReader)
         {
             Guard.ThrowIfNull(builder);
             Guard.ThrowIfNull(exportedItems);
@@ -45,45 +75,76 @@ public static MeterProviderBuilder AddInMemoryExporter(this MeterProviderBuilder
             {
                 return deferredMeterProviderBuilder.Configure((sp, builder) =>
                 {
-                    AddInMemoryExporter(builder, exportedItems, sp.GetOptions<MetricReaderOptions>(), null);
+                    AddInMemoryExporter(builder, exportedItems, sp.GetOptions<MetricReaderOptions>(), configureMetricReader);
                 });
             }
 
-            return AddInMemoryExporter(builder, exportedItems, new MetricReaderOptions(), null);
+            return AddInMemoryExporter(builder, exportedItems, new MetricReaderOptions(), configureMetricReader);
         }
 
         /// <summary>
         /// Adds InMemory metric exporter to the <see cref="MeterProviderBuilder"/> using default options.
         /// </summary>
         /// <param name="builder"><see cref="MeterProviderBuilder"/> builder to use.</param>
-        /// <param name="exportedItems">Collection which will be populated with the exported MetricItem.</param>
+        /// <param name="exportFunc">A function which will replace <see cref="InMemoryExporter{T}.Export(in Batch{T})"/>.</param>
         /// <param name="configureMetricReader"><see cref="MetricReader"/> configuration options.</param>
         /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
-        public static MeterProviderBuilder AddInMemoryExporter(this MeterProviderBuilder builder, ICollection<Metric> exportedItems, Action<MetricReaderOptions> configureMetricReader)
+        public static MeterProviderBuilder AddInMemoryExporter(
+            this MeterProviderBuilder builder,
+            Func<Batch<Metric>, ExportResult> exportFunc,
+            Action<MetricReaderOptions> configureMetricReader)
         {
             Guard.ThrowIfNull(builder);
-            Guard.ThrowIfNull(exportedItems);
+            Guard.ThrowIfNull(exportFunc);
 
             if (builder is IDeferredMeterProviderBuilder deferredMeterProviderBuilder)
             {
                 return deferredMeterProviderBuilder.Configure((sp, builder) =>
                 {
-                    AddInMemoryExporter(builder, exportedItems, sp.GetOptions<MetricReaderOptions>(), configureMetricReader);
+                    AddInMemoryExporter(builder, exportFunc, sp.GetOptions<MetricReaderOptions>(), configureMetricReader);
                 });
             }
 
-            return AddInMemoryExporter(builder, exportedItems, new MetricReaderOptions(), configureMetricReader);
+            return AddInMemoryExporter(builder, exportFunc, new MetricReaderOptions(), configureMetricReader);
+        }
+
+        private static MeterProviderBuilder AddInMemoryExporter(
+            MeterProviderBuilder builder,
+            ICollection<ExportableMetricCopy> exportedItems,
+            MetricReaderOptions metricReaderOptions,
+            Action<MetricReaderOptions> configureMetricReader)
+        {
+            configureMetricReader?.Invoke(metricReaderOptions);
+
+            var metricExporter = new InMemoryExporter<Metric>(
+                exportFunc: metricBatch =>
+                {
+                    foreach (var metric in metricBatch)
+                    {
+                        exportedItems.Add(new ExportableMetricCopy(metric));
+                    }
+
+                    return ExportResult.Success;
+                });
+
+            var metricReader = PeriodicExportingMetricReaderHelper.CreatePeriodicExportingMetricReader(
+                metricExporter,
+                metricReaderOptions,
+                DefaultExportIntervalMilliseconds,
+                DefaultExportTimeoutMilliseconds);
+
+            return builder.AddReader(metricReader);
         }
 
         private static MeterProviderBuilder AddInMemoryExporter(
             MeterProviderBuilder builder,
-            ICollection<Metric> exportedItems,
+            Func<Batch<Metric>, ExportResult> exportFunc,
             MetricReaderOptions metricReaderOptions,
             Action<MetricReaderOptions> configureMetricReader)
         {
             configureMetricReader?.Invoke(metricReaderOptions);
 
-            var metricExporter = new InMemoryExporter<Metric>(exportedItems);
+            var metricExporter = new InMemoryExporter<Metric>(exportFunc);
 
             var metricReader = PeriodicExportingMetricReaderHelper.CreatePeriodicExportingMetricReader(
                 metricExporter,

src/OpenTelemetry.Exporter.InMemory/OpenTelemetry.Exporter.InMemory.csproj

@@ -27,8 +27,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\PeriodicExportingMetricReaderHelper.cs" Link="Includes\PeriodicExportingMetricReaderHelper.cs" />
-    <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\ServiceProviderExtensions.cs" Link="Includes\ServiceProviderExtensions.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\Guard.cs" Link="Includes\Guard.cs" />
   </ItemGroup>
 

src/OpenTelemetry/AssemblyInfo.cs

@@ -17,6 +17,7 @@
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("OpenTelemetry.Tests" + AssemblyInfo.PublicKey)]
+[assembly: InternalsVisibleTo("OpenTelemetry.Exporter.InMemory" + AssemblyInfo.PublicKey)]
 [assembly: InternalsVisibleTo("OpenTelemetry.Exporter.Prometheus" + AssemblyInfo.PublicKey)]
 [assembly: InternalsVisibleTo("OpenTelemetry.Exporter.Prometheus.Tests" + AssemblyInfo.PublicKey)]
 [assembly: InternalsVisibleTo("OpenTelemetry.Extensions.Hosting.Tests" + AssemblyInfo.PublicKey)]

src/OpenTelemetry/Metrics/HistogramBuckets.cs

@@ -52,6 +52,7 @@ internal HistogramBuckets Copy()
             HistogramBuckets copy = new HistogramBuckets(this.ExplicitBounds);
 
             Array.Copy(this.SnapshotBucketCounts, copy.SnapshotBucketCounts, this.SnapshotBucketCounts.Length);
+            Array.Copy(this.RunningBucketCounts, copy.RunningBucketCounts, this.RunningBucketCounts.Length);
             copy.SnapshotSum = this.SnapshotSum;
 
             return copy;

test/Benchmarks/Benchmarks.csproj

@@ -32,4 +32,8 @@
     <ProjectReference Include="$(RepoRoot)\src\OpenTelemetry.Instrumentation.AspNetCore\OpenTelemetry.Instrumentation.AspNetCore.csproj" />
     <ProjectReference Include="$(RepoRoot)\src\OpenTelemetry.Instrumentation.Http\OpenTelemetry.Instrumentation.Http.csproj" />
   </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="$(RepoRoot)\test\OpenTelemetry.Tests\Shared\InMemoryExporterMetricsExtensions.cs" Link="Includes\InMemoryExporterMetricsExtensions.cs" />
+  </ItemGroup>
 </Project>

test/Benchmarks/Metrics/HistogramBenchmarks.cs

@@ -83,7 +83,7 @@ public void Setup()
                 this.bounds[i] = i * MaxValue / this.bounds.Length;
             }
 
-            var exportedItems = new List<Metric>();
+            var exportedItems = new List<ExportableMetricCopy>();
 
             this.provider = Sdk.CreateMeterProviderBuilder()
                 .AddMeter(this.meter.Name)

test/Benchmarks/Metrics/MetricsBenchmarks.cs

@@ -68,7 +68,7 @@ public void Setup()
         {
             this.meter = new Meter(Utils.GetCurrentMethodName());
 
-            var exportedItems = new List<Metric>();
+            var exportedItems = new List<ExportableMetricCopy>();
             this.provider = Sdk.CreateMeterProviderBuilder()
                 .AddMeter(this.meter.Name) // All instruments from this meter are enabled.
                 .AddInMemoryExporter(exportedItems, metricReaderOptions =>

test/Benchmarks/Metrics/MetricsViewBenchmarks.cs

@@ -45,7 +45,7 @@ public class MetricsViewBenchmarks
         private static readonly ThreadLocal<Random> ThreadLocalRandom = new(() => new Random());
         private static readonly string[] DimensionValues = new string[] { "DimVal1", "DimVal2", "DimVal3", "DimVal4", "DimVal5", "DimVal6", "DimVal7", "DimVal8", "DimVal9", "DimVal10" };
         private static readonly int DimensionsValuesLength = DimensionValues.Length;
-        private List<Metric> metrics;
+        private List<ExportableMetricCopy> metrics;
         private Counter<long> counter;
         private MeterProvider provider;
         private Meter meter;
@@ -81,7 +81,7 @@ public void Setup()
         {
             this.meter = new Meter(Utils.GetCurrentMethodName());
             this.counter = this.meter.CreateCounter<long>("counter");
-            this.metrics = new List<Metric>();
+            this.metrics = new List<ExportableMetricCopy>();
 
             if (this.ViewConfig == ViewConfiguration.NoView)
             {