[OpenTelemetry] Metrics - beter handling for double.NaN v2

src/OpenTelemetry/Internal/InterlockedHelper.cs

@@ -16,7 +16,7 @@ public static void Add(ref double location, double value)
         var currentValue = Volatile.Read(ref location);
 
         var returnedValue = Interlocked.CompareExchange(ref location, currentValue + value, currentValue);
-        if (!AreSame(returnedValue, currentValue))
+        if (returnedValue != currentValue)
         {
             AddRare(ref location, value, returnedValue);
         }
@@ -35,16 +35,12 @@ private static void AddRare(ref double location, double value, double currentVal
             sw.SpinOnce();
 
             var returnedValue = Interlocked.CompareExchange(ref location, currentValue + value, currentValue);
-            if (AreSame(returnedValue, currentValue))
+            if (returnedValue == currentValue)
             {
                 break;
             }
 
             currentValue = returnedValue;
         }
     }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static bool AreSame(double left, double right)
-        => BitConverter.DoubleToInt64Bits(left) == BitConverter.DoubleToInt64Bits(right);
 }

src/OpenTelemetry/Metrics/MeterProviderSdk.cs

@@ -219,6 +219,16 @@ internal static void MeasurementRecordedDouble(Instrument instrument, double val
             return;
         }
 
+        if (!MathHelper.IsFinite(value)
+            && instrument is Counter<double>
+                or UpDownCounter<double>
+                or ObservableCounter<double>
+                or ObservableUpDownCounter<double>)
+        {
+            OpenTelemetrySdkEventSource.Log.MeasurementDropped(instrument?.Name ?? "UnknownInstrument", "Measurement value was invalid.", "Use a finite value for sum instruments (not NaN or Infinity).");
+            return;
+        }
+
         metricState.RecordMeasurementDouble(value, tags);
     }
 

test/OpenTelemetry.Tests/Metrics/MeterProviderSdkTests.cs

@@ -104,4 +104,82 @@ void RunTest()
             }
         }
     }
+
+    [Fact]
+    public void NonFiniteCounterDoubleMeasurementsAreDropped()
+    {
+        var meterName = Utils.GetCurrentMethodName();
+        var exportedItems = new List<Metric>();
+
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddMeter(meterName)
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        using var meter = new Meter(meterName);
+        var counter = meter.CreateCounter<double>("counter");
+
+        counter.Add(double.NaN);
+        counter.Add(double.PositiveInfinity);
+        counter.Add(double.NegativeInfinity);
+        counter.Add(2.5);
+
+        Assert.True(meterProvider.ForceFlush());
+
+        var exportedMetric = Assert.Single(exportedItems);
+        var metric = new MetricSnapshot(exportedMetric);
+        var metricPoint = Assert.Single(metric.MetricPoints);
+        Assert.Equal(2.5, metricPoint.GetSumDouble());
+    }
+
+    [Fact]
+    public void NonFiniteUpDownCounterDoubleMeasurementsAreDropped()
+    {
+        var meterName = Utils.GetCurrentMethodName();
+        var exportedItems = new List<Metric>();
+
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddMeter(meterName)
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        using var meter = new Meter(meterName);
+        var upDownCounter = meter.CreateUpDownCounter<double>("updowncounter");
+
+        upDownCounter.Add(double.PositiveInfinity);
+        upDownCounter.Add(double.NegativeInfinity);
+        upDownCounter.Add(2.5);
+
+        Assert.True(meterProvider.ForceFlush());
+
+        var exportedMetric = Assert.Single(exportedItems);
+        var metric = new MetricSnapshot(exportedMetric);
+        var metricPoint = Assert.Single(metric.MetricPoints);
+        Assert.Equal(2.5, metricPoint.GetSumDouble());
+    }
+
+    [Fact]
+    public void NaNHistogramMeasurementsAreNotDropped()
+    {
+        var meterName = Utils.GetCurrentMethodName();
+        var exportedItems = new List<Metric>();
+
+        using var meterProvider = Sdk.CreateMeterProviderBuilder()
+            .AddMeter(meterName)
+            .AddInMemoryExporter(exportedItems)
+            .Build();
+
+        using var meter = new Meter(meterName);
+        var histogram = meter.CreateHistogram<double>("histogram");
+
+        histogram.Record(18);
+        histogram.Record(double.NaN);
+
+        Assert.True(meterProvider.ForceFlush());
+
+        var exportedMetric = Assert.Single(exportedItems);
+        var metric = new MetricSnapshot(exportedMetric);
+        var metricPoint = Assert.Single(metric.MetricPoints);
+        Assert.True(double.IsNaN(metricPoint.GetHistogramSum()));
+    }
 }