[sdk-metrics] Support .NET 9 Synchronous Gauge

docs/metrics/README.md

@@ -86,7 +86,7 @@ static readonly Meter MyMeter = new("MyCompany.MyProduct.MyLibrary", "1.0");
   | [Asynchronous Gauge](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#asynchronous-gauge) | [`ObservableGauge<T>`](https://learn.microsoft.com/dotnet/api/system.diagnostics.metrics.observablegauge-1) |
   | [Asynchronous UpDownCounter](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#asynchronous-updowncounter) | [`ObservableUpDownCounter<T>`](https://learn.microsoft.com/dotnet/api/system.diagnostics.metrics.observableupdowncounter-1) |
   | [Counter](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#counter) | [`Counter<T>`](https://learn.microsoft.com/dotnet/api/system.diagnostics.metrics.counter-1) |
-  | [Gauge](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#gauge) (experimental) | N/A |
+  | [Gauge](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#gauge) | [`Gauge<T>`](https://learn.microsoft.com/dotnet/api/system.diagnostics.metrics.gauge-1) |
   | [Histogram](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#histogram) | [`Histogram<T>`](https://learn.microsoft.com/dotnet/api/system.diagnostics.metrics.histogram-1) |
   | [UpDownCounter](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#updowncounter) | [`UpDownCounter<T>`](https://learn.microsoft.com/dotnet/api/system.diagnostics.metrics.updowncounter-1) |
 

src/OpenTelemetry/CHANGELOG.md

@@ -31,6 +31,11 @@ Notes](../../RELEASENOTES.md).
   See [#5854](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5854)
   for details.
 
+* Add support for collecting metrics from
+  [Gauge](https://learn.microsoft.com/dotnet/api/system.diagnostics.metrics.gauge-1)
+  API
+  ([#5867](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5867))
+
 ## 1.9.0
 
 Released 2024-Jun-14

src/OpenTelemetry/Metrics/Metric.cs

@@ -117,6 +117,12 @@ internal Metric(
             aggType = AggregationType.DoubleGauge;
             this.MetricType = MetricType.DoubleGauge;
         }
+        else if (instrumentIdentity.InstrumentType == typeof(Gauge<double>)
+            || instrumentIdentity.InstrumentType == typeof(Gauge<float>))
+        {
+            aggType = AggregationType.DoubleGauge;
+            this.MetricType = MetricType.DoubleGauge;
+        }
         else if (instrumentIdentity.InstrumentType == typeof(ObservableGauge<long>)
             || instrumentIdentity.InstrumentType == typeof(ObservableGauge<int>)
             || instrumentIdentity.InstrumentType == typeof(ObservableGauge<short>)
@@ -125,6 +131,14 @@ internal Metric(
             aggType = AggregationType.LongGauge;
             this.MetricType = MetricType.LongGauge;
         }
+        else if (instrumentIdentity.InstrumentType == typeof(Gauge<long>)
+            || instrumentIdentity.InstrumentType == typeof(Gauge<int>)
+            || instrumentIdentity.InstrumentType == typeof(Gauge<short>)
+            || instrumentIdentity.InstrumentType == typeof(Gauge<byte>))
+        {
+            aggType = AggregationType.LongGauge;
+            this.MetricType = MetricType.LongGauge;
+        }
         else if (instrumentIdentity.IsHistogram)
         {
             var explicitBucketBounds = instrumentIdentity.HistogramBucketBounds;

src/OpenTelemetry/Metrics/Reader/MetricReader.cs

@@ -27,6 +27,7 @@ public abstract partial class MetricReader : IDisposable
 
             // Temporality is not defined for gauges, so this does not really affect anything.
             var type when type == typeof(ObservableGauge<>) => AggregationTemporality.Delta,
+            var type when type == typeof(Gauge<>) => AggregationTemporality.Delta,
 
             var type when type == typeof(UpDownCounter<>) => AggregationTemporality.Cumulative,
             var type when type == typeof(ObservableUpDownCounter<>) => AggregationTemporality.Cumulative,

test/OpenTelemetry.Tests/Metrics/MetricApiTestsBase.cs

@@ -1613,6 +1613,98 @@ public void UnsupportedMetricInstrument()
         Assert.Empty(exportedItems);
     }
 
+    [Fact]
+    public void GaugeIsExportedCorrectly()
+    {
+        var exportedItems = new List<Metric>();
+
+        using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
+
+        using var container = this.BuildMeterProvider(out var meterProvider, builder => builder
+            .AddMeter(meter.Name)
+            .AddInMemoryExporter(exportedItems));
+
+        var gauge = meter.CreateGauge<long>(name: "NoiseLevel", unit: "dB", description: "Background Noise Level");
+        gauge.Record(10);
+        meterProvider.ForceFlush(MaxTimeToAllowForFlush);
+        Assert.Single(exportedItems);
+        var metric = exportedItems[0];
+        Assert.Equal("Background Noise Level", metric.Description);
+        List<MetricPoint> metricPoints = new List<MetricPoint>();
+        foreach (ref readonly var mp in metric.GetMetricPoints())
+        {
+            metricPoints.Add(mp);
+        }
+
+        var lastValue = metricPoints[0].GetGaugeLastValueLong();
+        Assert.Equal(10, lastValue);
+    }
+
+    [Theory]
+    [InlineData(MetricReaderTemporalityPreference.Cumulative)]
+    [InlineData(MetricReaderTemporalityPreference.Delta)]
+    public void GaugeHandlesNoNewMeasurementsCorrectlyWithTemporality(MetricReaderTemporalityPreference temporalityPreference)
+    {
+        var exportedMetrics = new List<Metric>();
+
+        using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
+        using var container = this.BuildMeterProvider(out var meterProvider, builder => builder
+            .AddMeter(meter.Name)
+            .AddInMemoryExporter(exportedMetrics, metricReaderOptions =>
+            {
+                metricReaderOptions.TemporalityPreference = temporalityPreference;
+            }));
+
+        var noiseLevelGauge = meter.CreateGauge<long>(name: "NoiseLevel", unit: "dB", description: "Background Noise Level");
+        noiseLevelGauge.Record(10);
+
+        // Force a flush to export the recorded data
+        meterProvider.ForceFlush(MaxTimeToAllowForFlush);
+
+        // Validate first export / flush
+        var firstMetric = exportedMetrics[0];
+        var firstMetricPoints = new List<MetricPoint>();
+        foreach (ref readonly var metricPoint in firstMetric.GetMetricPoints())
+        {
+            firstMetricPoints.Add(metricPoint);
+        }
+
+        Assert.Single(firstMetricPoints);
+        var firstMetricPoint = firstMetricPoints[0];
+        Assert.Equal(10, firstMetricPoint.GetGaugeLastValueLong());
+
+        // Flush the metrics again without recording any new measurements
+        meterProvider.ForceFlush(MaxTimeToAllowForFlush);
+
+        // Validate second export / flush
+        if (temporalityPreference == MetricReaderTemporalityPreference.Cumulative)
+        {
+            // For cumulative temporality, data points should still be collected
+            // without any new measurements
+            var secondMetric = exportedMetrics[1];
+            var secondMetricPoints = new List<MetricPoint>();
+            foreach (ref readonly var metricPoint in secondMetric.GetMetricPoints())
+            {
+                secondMetricPoints.Add(metricPoint);
+            }
+
+            Assert.Single(secondMetricPoints);
+            var secondMetricPoint = secondMetricPoints[0];
+            Assert.Equal(10, secondMetricPoint.GetGaugeLastValueLong());
+        }
+        else if (temporalityPreference == MetricReaderTemporalityPreference.Delta)
+        {
+            // For delta temporality, no new metric should be collected
+            // Expect an exception if we try to access exportedMetrics[1]
+            var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var secondMetric = exportedMetrics[1];
+            });
+
+            Assert.Contains("Index was out of range. Must be non-negative and less than the size of the collection.", exception.Message);
+        }
+    }
+
     internal static IConfiguration BuildConfiguration(bool emitOverflowAttribute, bool shouldReclaimUnusedMetricPoints)
     {
         var configurationData = new Dictionary<string, string>();