Improve Metrics pull export mode

docs/metrics/extending-the-sdk/MyExporter.cs

@@ -43,7 +43,6 @@ public override ExportResult Export(in Batch<Metric> batch)
             }
 
             sb.Append($"{record}");
-            sb.Append(')');
         }
 
         Console.WriteLine($"{this.name}.Export([{sb.ToString()}])");

src/OpenTelemetry.Exporter.Prometheus/MeterProviderBuilderExtensions.cs

@@ -39,13 +39,13 @@ public static MeterProviderBuilder AddPrometheusExporter(this MeterProviderBuild
             configure?.Invoke(options);
 
             var exporter = new PrometheusExporter(options);
+            var reader = new BaseExportingMetricReader(exporter);
 
-            var metricReader = new BaseExportingMetricReader(exporter);
-            exporter.CollectMetric = metricReader.Collect;
+            exporter.CollectMetric = timeout => exporter.Collect(reader, timeout);
 
             var metricsHttpServer = new PrometheusExporterMetricsHttpServer(exporter);
             metricsHttpServer.Start();
-            return builder.AddMetricReader(metricReader);
+            return builder.AddMetricReader(reader);
         }
     }
 }

src/OpenTelemetry/Metrics/BaseExportingMetricReader.cs

@@ -59,6 +59,23 @@ protected override bool ProcessMetrics(Batch<Metric> metrics, int timeoutMillise
             return this.exporter.Export(metrics) == ExportResult.Success;
         }
 
+        /// <inheritdoc />
+        protected override bool OnCollect(int timeoutMilliseconds)
+        {
+            if (this.supportedExportModes.HasFlag(ExportModes.Push))
+            {
+                return base.OnCollect(timeoutMilliseconds);
+            }
+
+            if (this.supportedExportModes.HasFlag(ExportModes.Pull) && PullMetricScope.IsPullAllowed)
+            {
+                return base.OnCollect(timeoutMilliseconds);
+            }
+
+            // TODO: add some error log
+            return false;
+        }
+
         /// <inheritdoc />
         protected override bool OnShutdown(int timeoutMilliseconds)
         {

src/OpenTelemetry/Metrics/MetricExporterExtensions.cs

@@ -0,0 +1,69 @@
+// <copyright file="MetricExporterExtensions.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;
+using System.Threading;
+
+namespace OpenTelemetry.Metrics
+{
+    /// <summary>
+    /// Contains extension methods for the <see cref="BaseExporter{Metric}"/> class.
+    /// </summary>
+    public static class MetricExporterExtensions
+    {
+        /// <summary>
+        /// Attempts to collect the metrics, blocks the current thread until
+        /// metrics collection completed or timed out.
+        /// </summary>
+        /// <param name="exporter">BaseExporter{Metric} instance on which Collect will be called.</param>
+        /// <param name="reader">BaseExportingMetricReader instance on which Collect will be called.</param>
+        /// <param name="timeoutMilliseconds">
+        /// The number (non-negative) of milliseconds to wait, or
+        /// <c>Timeout.Infinite</c> to wait indefinitely.
+        /// </param>
+        /// <returns>
+        /// Returns <c>true</c> when metrics collection succeeded; otherwise, <c>false</c>.
+        /// </returns>
+        /// <exception cref="System.ArgumentOutOfRangeException">
+        /// Thrown when the <c>timeoutMilliseconds</c> is smaller than -1.
+        /// </exception>
+        /// <remarks>
+        /// This function guarantees thread-safety.
+        /// </remarks>
+        public static bool Collect(this BaseExporter<Metric> exporter, BaseExportingMetricReader reader, int timeoutMilliseconds = Timeout.Infinite)
+        {
+            if (exporter == null)
+            {
+                throw new ArgumentNullException(nameof(exporter));
+            }
+
+            if (reader == null)
+            {
+                throw new ArgumentNullException(nameof(reader));
+            }
+
+            if (timeoutMilliseconds < 0 && timeoutMilliseconds != Timeout.Infinite)
+            {
+                throw new ArgumentOutOfRangeException(nameof(timeoutMilliseconds), timeoutMilliseconds, "timeoutMilliseconds should be non-negative or Timeout.Infinite.");
+            }
+
+            using (PullMetricScope.Begin())
+            {
+                return reader.Collect(timeoutMilliseconds);
+            }
+        }
+    }
+}

src/OpenTelemetry/Metrics/PullMetricScope.cs

@@ -0,0 +1,53 @@
+// <copyright file="PullMetricScope.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;
+using System.Runtime.CompilerServices;
+using OpenTelemetry.Context;
+
+namespace OpenTelemetry
+{
+    internal sealed class PullMetricScope : IDisposable
+    {
+        private static readonly RuntimeContextSlot<bool> Slot = RuntimeContext.RegisterSlot<bool>("otel.pull_metric");
+
+        private readonly bool previousValue;
+        private bool disposed;
+
+        internal PullMetricScope(bool value = true)
+        {
+            this.previousValue = Slot.Get();
+            Slot.Set(value);
+        }
+
+        internal static bool IsPullAllowed => Slot.Get();
+
+        public static IDisposable Begin(bool value = true)
+        {
+            return new PullMetricScope(value);
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (!this.disposed)
+            {
+                Slot.Set(this.previousValue);
+                this.disposed = true;
+            }
+        }
+    }
+}

test/OpenTelemetry.Tests/Metrics/MetricExporterTests.cs

@@ -0,0 +1,94 @@
+// <copyright file="MetricExporterTests.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;
+using System.Collections.Generic;
+using System.Diagnostics.Metrics;
+using Xunit;
+
+namespace OpenTelemetry.Metrics.Tests
+{
+    public class MetricExporterTests
+    {
+        [Theory]
+        [InlineData(ExportModes.Push)]
+        [InlineData(ExportModes.Pull)]
+        [InlineData(ExportModes.Pull | ExportModes.Push)]
+        public void FlushMetricExporterTest(ExportModes mode)
+        {
+            BaseExporter<Metric> exporter = null;
+
+            switch (mode)
+            {
+                case ExportModes.Push:
+                    exporter = new PushOnlyMetricExporter();
+                    break;
+                case ExportModes.Pull:
+                    exporter = new PullOnlyMetricExporter();
+                    break;
+                case ExportModes.Pull | ExportModes.Push:
+                    exporter = new PushPullMetricExporter();
+                    break;
+            }
+
+            using var meterProvider = Sdk.CreateMeterProviderBuilder()
+                .AddMetricReader(new BaseExportingMetricReader(exporter))
+                .Build();
+
+            var result = meterProvider.ForceFlush();
+
+            switch (mode)
+            {
+                case ExportModes.Push:
+                    Assert.True(result);
+                    break;
+                case ExportModes.Pull:
+                    Assert.False(result);
+                    break;
+                case ExportModes.Pull | ExportModes.Push:
+                    Assert.True(result);
+                    break;
+            }
+        }
+
+        [ExportModes(ExportModes.Push)]
+        private class PushOnlyMetricExporter : BaseExporter<Metric>
+        {
+            public override ExportResult Export(in Batch<Metric> batch)
+            {
+                return ExportResult.Success;
+            }
+        }
+
+        [ExportModes(ExportModes.Pull)]
+        private class PullOnlyMetricExporter : BaseExporter<Metric>
+        {
+            public override ExportResult Export(in Batch<Metric> batch)
+            {
+                return ExportResult.Success;
+            }
+        }
+
+        [ExportModes(ExportModes.Pull | ExportModes.Push)]
+        private class PushPullMetricExporter : BaseExporter<Metric>
+        {
+            public override ExportResult Export(in Batch<Metric> batch)
+            {
+                return ExportResult.Success;
+            }
+        }
+    }
+}