[OpenTelemetry] Drop non-finite values from histogram aggregations

src/OpenTelemetry/CHANGELOG.md

@@ -28,6 +28,12 @@ Notes](../../RELEASENOTES.md).
   initialized provider state.
   ([#7761](https://github.com/open-telemetry/opentelemetry-dotnet/pull/7761))
 
+* Non-finite histogram measurements (`NaN`, `+Inf`, `-Inf`) are now dropped
+  rather than recorded, so they can no longer permanently corrupt the sum,
+  min, and max of a cumulative histogram stream. This aligns the explicit-bucket
+  and exponential histograms with the metrics SDK specification.
+  ([#7759](https://github.com/open-telemetry/opentelemetry-dotnet/pull/7759))
+
 ## 1.18.0
 
 Released 2026-Aug-21

src/OpenTelemetry/Metrics/AggregatorStore.cs

@@ -55,6 +55,7 @@ internal sealed class AggregatorStore
     private readonly MetricPoint[] metricPoints;
     private readonly int[] currentMetricPointBatch;
     private readonly AggregationType aggType;
+    private readonly bool isHistogramAggregation;
     private readonly HistogramExplicitBounds histogramExplicitBounds;
     private readonly int exponentialHistogramMaxSize;
     private readonly int exponentialHistogramMaxScale;
@@ -93,6 +94,15 @@ internal AggregatorStore(
         this.exponentialHistogramMaxScale = metricStreamIdentity.ExponentialHistogramMaxScale;
         this.StartTimeExclusive = DateTimeOffset.UtcNow;
         this.ExemplarReservoirFactory = exemplarReservoirFactory;
+
+        this.isHistogramAggregation = aggType is
+            AggregationType.Histogram
+            or AggregationType.HistogramWithMinMax
+            or AggregationType.HistogramWithBuckets
+            or AggregationType.HistogramWithMinMaxBuckets
+            or AggregationType.Base2ExponentialHistogram
+            or AggregationType.Base2ExponentialHistogramWithMinMax;
+
         if (metricStreamIdentity.TagKeys != null)
         {
             this.updateLongCallback = this.UpdateLongCustomTags;
@@ -213,6 +223,14 @@ internal void Update(long value, ReadOnlySpan<KeyValuePair<string, object?>> tag
 
     internal void Update(double value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
     {
+        if (this.isHistogramAggregation && (double.IsNaN(value) || double.IsInfinity(value)))
+        {
+            // Reject non-finite histogram measurements before tag lookup: the value is always
+            // dropped, so a unique tag set carrying only non-finite values must not consume a
+            // cardinality slot that a subsequent, valid tag set could need.
+            return;
+        }
+
         try
         {
             this.updateDoubleCallback(value, tags);

src/OpenTelemetry/Metrics/MetricPoint/MetricPoint.cs

@@ -947,6 +947,13 @@ internal void NullifyMetricPointState()
 
     private void UpdateHistogram(double number, ReadOnlySpan<KeyValuePair<string, object?>> tags = default, bool offerExemplar = false)
     {
+        if (double.IsNaN(number) || double.IsInfinity(number))
+        {
+            // Non-finite values would poison RunningSum for the lifetime of a cumulative stream.
+            this.CompleteUpdateWithoutMeasurement();
+            return;
+        }
+
         var histogramBuckets = this.mpComponents!.HistogramBuckets!;
 
         this.mpComponents.AcquireLock();
@@ -966,6 +973,14 @@ private void UpdateHistogram(double number, ReadOnlySpan<KeyValuePair<string, ob
 
     private void UpdateHistogramWithMinMax(double number, ReadOnlySpan<KeyValuePair<string, object?>> tags = default, bool offerExemplar = false)
     {
+        if (double.IsNaN(number) || double.IsInfinity(number))
+        {
+            // Non-finite values would poison RunningSum/RunningMin/RunningMax for the lifetime of
+            // a cumulative stream.
+            this.CompleteUpdateWithoutMeasurement();
+            return;
+        }
+
         var histogramBuckets = this.mpComponents!.HistogramBuckets!;
 
         this.mpComponents.AcquireLock();
@@ -988,6 +1003,13 @@ private void UpdateHistogramWithMinMax(double number, ReadOnlySpan<KeyValuePair<
 
     private void UpdateHistogramWithBuckets(double number, ReadOnlySpan<KeyValuePair<string, object?>> tags = default, bool offerExemplar = false)
     {
+        if (double.IsNaN(number) || double.IsInfinity(number))
+        {
+            // Non-finite values would poison RunningSum for the lifetime of a cumulative stream.
+            this.CompleteUpdateWithoutMeasurement();
+            return;
+        }
+
         var histogramBuckets = this.mpComponents!.HistogramBuckets!;
 
         var bucketIndex = histogramBuckets.FindBucketIndex(number);
@@ -1010,6 +1032,14 @@ private void UpdateHistogramWithBuckets(double number, ReadOnlySpan<KeyValuePair
 
     private void UpdateHistogramWithBucketsAndMinMax(double number, ReadOnlySpan<KeyValuePair<string, object?>> tags = default, bool offerExemplar = false)
     {
+        if (double.IsNaN(number) || double.IsInfinity(number))
+        {
+            // Non-finite values would poison RunningSum/RunningMin/RunningMax for the lifetime of
+            // a cumulative stream.
+            this.CompleteUpdateWithoutMeasurement();
+            return;
+        }
+
         var histogramBuckets = this.mpComponents!.HistogramBuckets!;
 
         var bucketIndex = histogramBuckets.FindBucketIndex(number);
@@ -1035,8 +1065,10 @@ private void UpdateHistogramWithBucketsAndMinMax(double number, ReadOnlySpan<Key
 
     private void UpdateBase2ExponentialHistogram(double number, ReadOnlySpan<KeyValuePair<string, object?>> tags = default, bool offerExemplar = false)
     {
-        if (number < 0)
+        if (number < 0 || double.IsNaN(number) || double.IsInfinity(number))
         {
+            // Negatives are undefined for exponential histograms; non-finite values would also
+            // poison RunningSum/RunningMin/RunningMax for the lifetime of a cumulative stream.
             this.CompleteUpdateWithoutMeasurement();
             return;
         }
@@ -1061,8 +1093,10 @@ private void UpdateBase2ExponentialHistogram(double number, ReadOnlySpan<KeyValu
 
     private void UpdateBase2ExponentialHistogramWithMinMax(double number, ReadOnlySpan<KeyValuePair<string, object?>> tags = default, bool offerExemplar = false)
     {
-        if (number < 0)
+        if (number < 0 || double.IsNaN(number) || double.IsInfinity(number))
         {
+            // Negatives are undefined for exponential histograms; non-finite values would also
+            // poison RunningSum/RunningMin/RunningMax for the lifetime of a cumulative stream.
             this.CompleteUpdateWithoutMeasurement();
             return;
         }

test/OpenTelemetry.Exporter.Prometheus.HttpListener.Tests/snapshots/PrometheusSerializer.HistogramInfinities.verified.txt

@@ -14,6 +14,6 @@ test_histogram_bucket{otel_scope_name="HistogramInfinities",le="2500"} 1
 test_histogram_bucket{otel_scope_name="HistogramInfinities",le="5000"} 1
 test_histogram_bucket{otel_scope_name="HistogramInfinities",le="7500"} 1
 test_histogram_bucket{otel_scope_name="HistogramInfinities",le="10000"} 1
-test_histogram_bucket{otel_scope_name="HistogramInfinities",le="+Inf"} 3
-test_histogram_sum{otel_scope_name="HistogramInfinities"} +Inf
-test_histogram_count{otel_scope_name="HistogramInfinities"} 3
+test_histogram_bucket{otel_scope_name="HistogramInfinities",le="+Inf"} 1
+test_histogram_sum{otel_scope_name="HistogramInfinities"} 18
+test_histogram_count{otel_scope_name="HistogramInfinities"} 1

test/OpenTelemetry.Exporter.Prometheus.HttpListener.Tests/snapshots/PrometheusSerializer.HistogramNaN.verified.txt

@@ -14,6 +14,6 @@ test_histogram_bucket{otel_scope_name="HistogramNaN",le="2500"} 1
 test_histogram_bucket{otel_scope_name="HistogramNaN",le="5000"} 1
 test_histogram_bucket{otel_scope_name="HistogramNaN",le="7500"} 1
 test_histogram_bucket{otel_scope_name="HistogramNaN",le="10000"} 1
-test_histogram_bucket{otel_scope_name="HistogramNaN",le="+Inf"} 3
-test_histogram_sum{otel_scope_name="HistogramNaN"} NaN
-test_histogram_count{otel_scope_name="HistogramNaN"} 3
+test_histogram_bucket{otel_scope_name="HistogramNaN",le="+Inf"} 1
+test_histogram_sum{otel_scope_name="HistogramNaN"} 18
+test_histogram_count{otel_scope_name="HistogramNaN"} 1

test/OpenTelemetry.Tests/Metrics/AggregatorTests.cs

@@ -21,6 +21,81 @@ public AggregatorTests()
 
     public static TheoryData<HistogramBoundaryTestCase> HistogramInfinityBoundariesTestCases => HistogramBoundaryTestCase.HistogramInfinityBoundariesTestCases();
 
+    public static TheoryData<int, double, bool> NonFiniteHistogramMeasurementTestCases()
+    {
+        var data = new TheoryData<int, double, bool>();
+
+        // Typed as an integer as AggregationType is internal
+        AggregationType[] aggregationTypes =
+        [
+            AggregationType.Histogram,
+            AggregationType.HistogramWithMinMax,
+            AggregationType.HistogramWithBuckets,
+            AggregationType.HistogramWithMinMaxBuckets,
+            AggregationType.Base2ExponentialHistogram,
+            AggregationType.Base2ExponentialHistogramWithMinMax,
+        ];
+
+        double[] nonFiniteValues = [double.NaN, double.PositiveInfinity, double.NegativeInfinity];
+
+        foreach (var aggregationType in aggregationTypes)
+        {
+            foreach (var nonFinite in nonFiniteValues)
+            {
+                data.Add((int)aggregationType, nonFinite, false);
+                data.Add((int)aggregationType, nonFinite, true);
+            }
+        }
+
+        return data;
+    }
+
+    [Theory]
+    [MemberData(nameof(NonFiniteHistogramMeasurementTestCases))]
+    public void NonFiniteMeasurementIsIgnoredByHistogram(int aggregationTypeValue, double nonFinite, bool outputDelta)
+    {
+        var aggregationType = (AggregationType)aggregationTypeValue;
+        var boundaries = new HistogramExplicitBounds(Metric.DefaultHistogramBounds);
+        var temporality = outputDelta ? AggregationTemporality.Delta : AggregationTemporality.Cumulative;
+        var aggregatorStore = new AggregatorStore(MetricStreamIdentity, aggregationType, temporality, 1024);
+        var histogramPoint = new MetricPoint(aggregatorStore, aggregationType, null, boundaries, Metric.DefaultExponentialHistogramMaxBuckets, Metric.DefaultExponentialHistogramMaxScale);
+
+        histogramPoint.Update(1);
+        histogramPoint.Update(nonFinite);
+        histogramPoint.Update(2);
+        histogramPoint.Update(3);
+
+        histogramPoint.TakeSnapshot(outputDelta);
+
+        // The non-finite measurement is dropped: only the three finite values are counted...
+        Assert.Equal(3, histogramPoint.GetHistogramCount());
+
+        // ...and the sum is exactly 1 + 2 + 3, not poisoned to NaN/Infinity.
+        Assert.Equal(6, histogramPoint.GetHistogramSum());
+
+        if (aggregationType is AggregationType.HistogramWithMinMax or
+            AggregationType.HistogramWithMinMaxBuckets or
+            AggregationType.Base2ExponentialHistogramWithMinMax)
+        {
+            // Min/max are not poisoned to NaN/Infinity either.
+            Assert.True(histogramPoint.TryGetHistogramMinMaxValues(out var min, out var max));
+            Assert.Equal(1, min);
+            Assert.Equal(3, max);
+        }
+
+        if (aggregationType is AggregationType.HistogramWithBuckets or AggregationType.HistogramWithMinMaxBuckets)
+        {
+            // The non-finite measurement was not distributed into any explicit bucket.
+            var bucketedCount = 0L;
+            foreach (var bucket in histogramPoint.GetHistogramBuckets())
+            {
+                bucketedCount += bucket.BucketCount;
+            }
+
+            Assert.Equal(3, bucketedCount);
+        }
+    }
+
     [Fact]
     public void HistogramDistributeToAllBucketsDefault()
     {

test/OpenTelemetry.Tests/Metrics/MetricOverflowAttributeTests.cs

@@ -291,4 +291,51 @@ public void MetricOverflowAttributeIsRecordedCorrectlyForHistogram(MetricReaderT
             Assert.Equal(12505, overflowMetricPoint.GetHistogramSum());
         }
     }
+
+    [Theory]
+    [InlineData(MetricReaderTemporalityPreference.Delta)]
+    [InlineData(MetricReaderTemporalityPreference.Cumulative)]
+    public void NonFiniteHistogramMeasurementsDoNotConsumeCardinality(MetricReaderTemporalityPreference temporalityPreference)
+    {
+        var exportedItems = new List<Metric>();
+
+        using var meter = new Meter(Utils.GetCurrentMethodName());
+        var histogram = meter.CreateHistogram<double>("TestHistogram");
+
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddMeter(meter.Name)
+            .AddView(histogram.Name, new ExplicitBucketHistogramConfiguration { CardinalityLimit = 3 })
+            .AddInMemoryExporter(exportedItems, metricReaderOptions => metricReaderOptions.TemporalityPreference = temporalityPreference)
+            .Build();
+
+        histogram.Record(double.NaN, new KeyValuePair<string, object?>("Key", 1));
+        histogram.Record(double.PositiveInfinity, new KeyValuePair<string, object?>("Key", 2));
+        histogram.Record(double.NegativeInfinity, new KeyValuePair<string, object?>("Key", 3));
+
+        histogram.Record(42, new KeyValuePair<string, object?>("Key", 4));
+        histogram.Record(42, new KeyValuePair<string, object?>("Key", 5));
+        histogram.Record(42, new KeyValuePair<string, object?>("Key", 6));
+
+        meterProvider.ForceFlush();
+
+        Assert.Single(exportedItems);
+        var metric = exportedItems[0];
+
+        var metricPoints = new List<MetricPoint>();
+        foreach (ref readonly var mp in metric.GetMetricPoints())
+        {
+            metricPoints.Add(mp);
+        }
+
+        // The non-finite measurements never occupied a MetricPoint, so no overflow occurred.
+        Assert.DoesNotContain(metricPoints, mp => mp.Tags.Count != 0 && mp.Tags.KeyAndValues[0].Key == "otel.metric.overflow");
+
+        var taggedMetricPoints = metricPoints.Where(mp => mp.Tags.Count != 0).ToList();
+        Assert.Equal(3, taggedMetricPoints.Count);
+        foreach (var mp in taggedMetricPoints)
+        {
+            Assert.Equal(1, mp.GetHistogramCount());
+            Assert.Equal(42, mp.GetHistogramSum());
+        }
+    }
 }

test/OpenTelemetry.Tests/Metrics/MetricTestData.cs

@@ -40,8 +40,7 @@ internal static class MetricTestData
     public static TheoryData<double[], HistogramConfiguration, double, double> ValidHistogramMinMax => new()
     {
         { [-10.0, 0.0, 1.0, 9.0, 10.0, 11.0, 19.0], new HistogramConfiguration(), -10.0, 19.0 },
-        { [double.NegativeInfinity], new HistogramConfiguration(), double.NegativeInfinity, double.NegativeInfinity },
-        { [double.NegativeInfinity, 0.0, double.PositiveInfinity], new HistogramConfiguration(), double.NegativeInfinity, double.PositiveInfinity },
+        { [double.NegativeInfinity, 0.0, double.PositiveInfinity], new HistogramConfiguration(), 0.0, 0.0 },
         { [1.0], new HistogramConfiguration(), 1.0, 1.0 },
         { [5.0, 100.0, 4.0, 101.0, -2.0, 97.0], new ExplicitBucketHistogramConfiguration { Boundaries = [10.0, 20.0] }, -2.0, 101.0 },
         { [5.0, 100.0, 4.0, 101.0, -2.0, 97.0], new Base2ExponentialBucketHistogramConfiguration(), 4.0, 101.0 },

test/OpenTelemetry.Tests/Metrics/MetricViewTests.cs

@@ -974,6 +974,31 @@ public void HistogramMinMaxNotPresent(double[] values, HistogramConfiguration hi
         Assert.False(histogramPoint.TryGetHistogramMinMaxValues(out var _, out var _));
     }
 
+    [Theory]
+    [InlineData(MetricReaderTemporalityPreference.Cumulative)]
+    [InlineData(MetricReaderTemporalityPreference.Delta)]
+    public void AllNonFiniteHistogramMeasurementsProduceNoMetricPoints(MetricReaderTemporalityPreference temporalityPreference)
+    {
+        using var meter = new Meter(Utils.GetCurrentMethodName());
+        var histogram = meter.CreateHistogram<double>("MyHistogram");
+        var exportedItems = new List<Metric>();
+
+        using var container = BuildMeterProvider(out var meterProvider, builder => builder
+            .AddMeter(meter.Name)
+            .AddInMemoryExporter(exportedItems, o => o.TemporalityPreference = temporalityPreference));
+
+        histogram.Record(double.NaN);
+        histogram.Record(double.PositiveInfinity);
+        histogram.Record(double.NegativeInfinity);
+
+        meterProvider.ForceFlush(MaxTimeToAllowForFlush);
+
+        // Every measurement was non-finite and dropped, so the stream never had a valid
+        // measurement recorded against it: nothing is exported, rather than an "empty"
+        // histogram with a count and sum of zero.
+        Assert.Empty(exportedItems);
+    }
+
     [Fact]
     public void ViewToSelectTagKeys()
     {