Add support for decimal instruments

src/OpenTelemetry/.publicApi/Stable/PublicAPI.Unshipped.txt

@@ -1,3 +1,4 @@
+abstract OpenTelemetry.Metrics.ExemplarReservoir.Offer(in OpenTelemetry.Metrics.ExemplarMeasurement<decimal> measurement) -> void
 OpenTelemetry.Metrics.Exemplar
 OpenTelemetry.Metrics.Exemplar.DoubleValue.get -> double
 OpenTelemetry.Metrics.Exemplar.Exemplar() -> void
@@ -10,7 +11,12 @@ OpenTelemetry.Metrics.ExemplarFilterType
 OpenTelemetry.Metrics.ExemplarFilterType.AlwaysOff = 0 -> OpenTelemetry.Metrics.ExemplarFilterType
 OpenTelemetry.Metrics.ExemplarFilterType.AlwaysOn = 1 -> OpenTelemetry.Metrics.ExemplarFilterType
 OpenTelemetry.Metrics.ExemplarFilterType.TraceBased = 2 -> OpenTelemetry.Metrics.ExemplarFilterType
+OpenTelemetry.Metrics.MetricPoint.GetGaugeLastValueDecimal() -> decimal
+OpenTelemetry.Metrics.MetricPoint.GetSumDecimal() -> decimal
 OpenTelemetry.Metrics.MetricPoint.TryGetExemplars(out OpenTelemetry.Metrics.ReadOnlyExemplarCollection exemplars) -> bool
+OpenTelemetry.Metrics.MetricType.DecimalGauge = 46 -> OpenTelemetry.Metrics.MetricType
+OpenTelemetry.Metrics.MetricType.DecimalSum = 30 -> OpenTelemetry.Metrics.MetricType
+OpenTelemetry.Metrics.MetricType.DecimalSumNonMonotonic = 142 -> OpenTelemetry.Metrics.MetricType
 OpenTelemetry.Metrics.ReadOnlyExemplarCollection
 OpenTelemetry.Metrics.ReadOnlyExemplarCollection.Enumerator
 OpenTelemetry.Metrics.ReadOnlyExemplarCollection.Enumerator.Current.get -> OpenTelemetry.Metrics.Exemplar

src/OpenTelemetry/Metrics/AggregationType.cs

@@ -69,4 +69,19 @@ internal enum AggregationType
     /// Exponential Histogram with sum, count, min, max.
     /// </summary>
     Base2ExponentialHistogramWithMinMax = 11,
+
+    /// <summary>
+    /// Calculate SUM from incoming delta measurements.
+    /// </summary>
+    DecimalSumIncomingDelta = 12,
+
+    /// <summary>
+    /// Calculate SUM from incoming cumulative measurements.
+    /// </summary>
+    DecimalSumIncomingCumulative = 13,
+
+    /// <summary>
+    /// Keep LastValue.
+    /// </summary>
+    DecimalGauge = 14,
 }

src/OpenTelemetry/Metrics/AggregatorStore.cs

@@ -51,6 +51,7 @@ internal sealed class AggregatorStore
     private readonly int exponentialHistogramMaxScale;
     private readonly UpdateLongDelegate updateLongCallback;
     private readonly UpdateDoubleDelegate updateDoubleCallback;
+    private readonly UpdateDecimalDelegate updateDecimalCallback;
     private readonly ExemplarFilterType exemplarFilter;
     private readonly Func<KeyValuePair<string, object?>[], int, int> lookupAggregatorStore;
 
@@ -91,11 +92,13 @@ internal AggregatorStore(
         {
             this.updateLongCallback = this.UpdateLong;
             this.updateDoubleCallback = this.UpdateDouble;
+            this.updateDecimalCallback = this.UpdateDecimal;
         }
         else
         {
             this.updateLongCallback = this.UpdateLongCustomTags;
             this.updateDoubleCallback = this.UpdateDoubleCustomTags;
+            this.updateDecimalCallback = this.UpdateDecimalCustomTags;
 #if NET8_0_OR_GREATER
             var hs = FrozenSet.ToFrozenSet(metricStreamIdentity.TagKeys, StringComparer.Ordinal);
 #else
@@ -150,6 +153,8 @@ internal AggregatorStore(
 
     private delegate void UpdateDoubleDelegate(double value, ReadOnlySpan<KeyValuePair<string, object?>> tags);
 
+    private delegate void UpdateDecimalDelegate(decimal value, ReadOnlySpan<KeyValuePair<string, object?>> tags);
+
     internal DateTimeOffset StartTimeExclusive { get; private set; }
 
     internal DateTimeOffset EndTimeInclusive { get; private set; }
@@ -189,6 +194,19 @@ internal void Update(double value, ReadOnlySpan<KeyValuePair<string, object?>> t
         }
     }
 
+    internal void Update(decimal value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
+    {
+        try
+        {
+            this.updateDecimalCallback(value, tags);
+        }
+        catch (Exception)
+        {
+            Interlocked.Increment(ref this.DroppedMeasurements);
+            OpenTelemetrySdkEventSource.Log.MeasurementDropped(this.name, "SDK internal error occurred.", "Contact SDK owners.");
+        }
+    }
+
     internal int Snapshot()
     {
         this.batchSize = 0;
@@ -1043,6 +1061,20 @@ private void UpdateDoubleCustomTags(double value, ReadOnlySpan<KeyValuePair<stri
         this.UpdateDoubleMetricPoint(index, value, tags);
     }
 
+    private void UpdateDecimal(decimal value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
+    {
+        var index = this.FindMetricAggregatorsDefault(tags);
+
+        this.UpdateDecimalMetricPoint(index, value, tags);
+    }
+
+    private void UpdateDecimalCustomTags(decimal value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
+    {
+        var index = this.FindMetricAggregatorsCustomTag(tags);
+
+        this.UpdateDecimalMetricPoint(index, value, tags);
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void UpdateDoubleMetricPoint(int metricPointIndex, double value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
     {
@@ -1084,6 +1116,47 @@ private void UpdateDoubleMetricPoint(int metricPointIndex, double value, ReadOnl
         }
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void UpdateDecimalMetricPoint(int metricPointIndex, decimal value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
+    {
+        if (metricPointIndex < 0)
+        {
+            Interlocked.Increment(ref this.DroppedMeasurements);
+
+            if (this.EmitOverflowAttribute)
+            {
+                this.InitializeOverflowTagPointIfNotInitialized();
+                this.metricPoints[1].Update(value);
+            }
+            else if (Interlocked.CompareExchange(ref this.metricCapHitMessageLogged, 1, 0) == 0)
+            {
+                OpenTelemetrySdkEventSource.Log.MeasurementDropped(this.name, this.metricPointCapHitMessage, MetricPointCapHitFixMessage);
+            }
+
+            return;
+        }
+
+        var exemplarFilterType = this.exemplarFilter;
+        if (exemplarFilterType == ExemplarFilterType.AlwaysOff)
+        {
+            this.metricPoints[metricPointIndex].Update(value);
+        }
+        else if (exemplarFilterType == ExemplarFilterType.AlwaysOn)
+        {
+            this.metricPoints[metricPointIndex].UpdateWithExemplar(
+                value,
+                tags,
+                offerExemplar: true);
+        }
+        else
+        {
+            this.metricPoints[metricPointIndex].UpdateWithExemplar(
+                value,
+                tags,
+                offerExemplar: Activity.Current?.Recorded ?? false);
+        }
+    }
+
     private int FindMetricAggregatorsDefault(ReadOnlySpan<KeyValuePair<string, object?>> tags)
     {
         int tagLength = tags.Length;

src/OpenTelemetry/Metrics/Exemplar/AlignedHistogramBucketExemplarReservoir.cs

@@ -32,4 +32,13 @@ public override void Offer(in ExemplarMeasurement<double> measurement)
 
         this.UpdateExemplar(measurement.ExplicitBucketHistogramBucketIndex, in measurement);
     }
+
+    public override void Offer(in ExemplarMeasurement<decimal> measurement)
+    {
+        Debug.Assert(
+            measurement.ExplicitBucketHistogramBucketIndex != -1,
+            "ExplicitBucketHistogramBucketIndex was -1");
+
+        this.UpdateExemplar(measurement.ExplicitBucketHistogramBucketIndex, in measurement);
+    }
 }

src/OpenTelemetry/Metrics/Exemplar/ExemplarReservoir.cs

@@ -58,6 +58,12 @@ internal ExemplarReservoir()
     /// <param name="measurement"><see cref="ExemplarMeasurement{T}"/>.</param>
     public abstract void Offer(in ExemplarMeasurement<double> measurement);
 
+    /// <summary>
+    /// Offers a measurement to the reservoir.
+    /// </summary>
+    /// <param name="measurement"><see cref="ExemplarMeasurement{T}"/>.</param>
+    public abstract void Offer(in ExemplarMeasurement<decimal> measurement);
+
     /// <summary>
     /// Collects all the exemplars accumulated by the Reservoir.
     /// </summary>

src/OpenTelemetry/Metrics/Exemplar/SimpleFixedSizeExemplarReservoir.cs

@@ -32,6 +32,11 @@ public override void Offer(in ExemplarMeasurement<double> measurement)
         this.Offer(in measurement);
     }
 
+    public override void Offer(in ExemplarMeasurement<decimal> measurement)
+    {
+        this.Offer(in measurement);
+    }
+
     protected override void OnCollected()
     {
         // Reset internal state irrespective of temporality.

src/OpenTelemetry/Metrics/MeterProviderSdk.cs

@@ -180,6 +180,9 @@ internal MeterProviderSdk(
         this.listener.SetMeasurementEventCallback<short>(static (instrument, value, tags, state) => MeasurementRecordedLong(instrument, value, tags, state));
         this.listener.SetMeasurementEventCallback<byte>(static (instrument, value, tags, state) => MeasurementRecordedLong(instrument, value, tags, state));
 
+        // decimal
+        this.listener.SetMeasurementEventCallback<decimal>(MeasurementRecordedDecimal);
+
         this.listener.MeasurementsCompleted = MeasurementsCompleted;
 
         this.listener.Start();
@@ -228,6 +231,17 @@ internal static void MeasurementRecordedDouble(Instrument instrument, double val
         metricState.RecordMeasurementDouble(value, tags);
     }
 
+    internal static void MeasurementRecordedDecimal(Instrument instrument, decimal value, ReadOnlySpan<KeyValuePair<string, object?>> tags, object? state)
+    {
+        if (state is not MetricState metricState)
+        {
+            OpenTelemetrySdkEventSource.Log.MeasurementDropped(instrument?.Name ?? "UnknownInstrument", "SDK internal error occurred.", "Contact SDK owners.");
+            return;
+        }
+
+        metricState.RecordMeasurementDecimal(value, tags);
+    }
+
     internal object? InstrumentPublished(Instrument instrument, bool listeningIsManagedExternally)
     {
         var listenToInstrumentUsingSdkConfiguration = this.shouldListenTo(instrument);

src/OpenTelemetry/Metrics/Metric.cs

@@ -83,6 +83,16 @@ internal Metric(
             aggType = AggregationType.DoubleSumIncomingCumulative;
             this.MetricType = MetricType.DoubleSum;
         }
+        else if (instrumentIdentity.InstrumentType == typeof(Counter<decimal>))
+        {
+            aggType = AggregationType.DecimalSumIncomingDelta;
+            this.MetricType = MetricType.DecimalSum;
+        }
+        else if (instrumentIdentity.InstrumentType == typeof(ObservableCounter<decimal>))
+        {
+            aggType = AggregationType.DecimalSumIncomingCumulative;
+            this.MetricType = MetricType.DecimalSum;
+        }
         else if (instrumentIdentity.InstrumentType == typeof(ObservableUpDownCounter<long>)
             || instrumentIdentity.InstrumentType == typeof(ObservableUpDownCounter<int>)
             || instrumentIdentity.InstrumentType == typeof(ObservableUpDownCounter<short>)
@@ -111,6 +121,16 @@ internal Metric(
             aggType = AggregationType.DoubleSumIncomingCumulative;
             this.MetricType = MetricType.DoubleSumNonMonotonic;
         }
+        else if (instrumentIdentity.InstrumentType == typeof(UpDownCounter<decimal>))
+        {
+            aggType = AggregationType.DecimalSumIncomingDelta;
+            this.MetricType = MetricType.DecimalSumNonMonotonic;
+        }
+        else if (instrumentIdentity.InstrumentType == typeof(ObservableUpDownCounter<decimal>))
+        {
+            aggType = AggregationType.DecimalSumIncomingCumulative;
+            this.MetricType = MetricType.DecimalSumNonMonotonic;
+        }
         else if (instrumentIdentity.InstrumentType == typeof(ObservableGauge<double>)
             || instrumentIdentity.InstrumentType == typeof(ObservableGauge<float>))
         {
@@ -125,12 +145,18 @@ internal Metric(
             aggType = AggregationType.LongGauge;
             this.MetricType = MetricType.LongGauge;
         }
+        else if (instrumentIdentity.InstrumentType == typeof(ObservableGauge<decimal>))
+        {
+            aggType = AggregationType.DecimalGauge;
+            this.MetricType = MetricType.DecimalGauge;
+        }
         else if (instrumentIdentity.InstrumentType == typeof(Histogram<long>)
             || instrumentIdentity.InstrumentType == typeof(Histogram<int>)
             || instrumentIdentity.InstrumentType == typeof(Histogram<short>)
             || instrumentIdentity.InstrumentType == typeof(Histogram<byte>)
             || instrumentIdentity.InstrumentType == typeof(Histogram<float>)
-            || instrumentIdentity.InstrumentType == typeof(Histogram<double>))
+            || instrumentIdentity.InstrumentType == typeof(Histogram<double>)
+            || instrumentIdentity.InstrumentType == typeof(Histogram<decimal>))
         {
             var explicitBucketBounds = instrumentIdentity.HistogramBucketBounds;
             var exponentialMaxSize = instrumentIdentity.ExponentialHistogramMaxSize;
@@ -228,6 +254,9 @@ internal void UpdateLong(long value, ReadOnlySpan<KeyValuePair<string, object?>>
     internal void UpdateDouble(double value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
         => this.AggregatorStore.Update(value, tags);
 
+    internal void UpdateDecimal(decimal value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
+        => this.AggregatorStore.Update(value, tags);
+
     internal int Snapshot()
         => this.AggregatorStore.Snapshot();
 }