fix: adding is_monotonic flag to sum

exporter/otlp-metrics/lib/opentelemetry/exporter/otlp/metrics/metrics_exporter.rb

@@ -240,7 +240,8 @@ def as_otlp_metrics(metrics)
                   aggregation_temporality: as_otlp_aggregation_temporality(metrics.aggregation_temporality),
                   data_points: metrics.data_points.map do |ndp|
                     number_data_point(ndp)
-                  end
+                  end,
+                  is_monotonic: metrics.is_monotonic
                 )
               )
 

exporter/otlp-metrics/test/opentelemetry/exporter/otlp/metrics/metrics_exporter_test.rb

@@ -580,6 +580,9 @@
       counter = meter.create_counter('test_counter', unit: 'smidgen', description: 'a small amount of something')
       counter.add(5, attributes: { 'foo' => 'bar' })
 
+      up_down_counter = meter.create_up_down_counter('test_up_down_counter', unit: 'smidgen', description: 'a small amount of something')
+      up_down_counter.add(5, attributes: { 'foo' => 'bar' })
+
       histogram = meter.create_histogram('test_histogram', unit: 'smidgen', description: 'a small amount of something')
       histogram.record(10, attributes: { 'oof' => 'rab' })
 
@@ -623,6 +626,27 @@
                             exemplars: nil
                           )
                         ],
+                        is_monotonic: true,
+                        aggregation_temporality: Opentelemetry::Proto::Metrics::V1::AggregationTemporality::AGGREGATION_TEMPORALITY_DELTA
+                      )
+                    ),
+                    Opentelemetry::Proto::Metrics::V1::Metric.new(
+                      name: 'test_up_down_counter',
+                      description: 'a small amount of something',
+                      unit: 'smidgen',
+                      sum: Opentelemetry::Proto::Metrics::V1::Sum.new(
+                        data_points: [
+                          Opentelemetry::Proto::Metrics::V1::NumberDataPoint.new(
+                            attributes: [
+                              Opentelemetry::Proto::Common::V1::KeyValue.new(key: 'foo', value: Opentelemetry::Proto::Common::V1::AnyValue.new(string_value: 'bar'))
+                            ],
+                            as_int: 5,
+                            start_time_unix_nano: 1_699_593_427_329_946_585,
+                            time_unix_nano: 1_699_593_427_329_946_586,
+                            exemplars: nil
+                          )
+                        ],
+                        is_monotonic: false,
                         aggregation_temporality: Opentelemetry::Proto::Metrics::V1::AggregationTemporality::AGGREGATION_TEMPORALITY_DELTA
                       )
                     ),

metrics_sdk/lib/opentelemetry/sdk/metrics/aggregation/sum.rb

@@ -11,11 +11,12 @@ module Aggregation
         # Contains the implementation of the Sum aggregation
         # https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#sum-aggregation
         class Sum
-          attr_reader :aggregation_temporality
+          attr_reader :aggregation_temporality, :is_monotonic
 
-          def initialize(aggregation_temporality: ENV.fetch('OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE', :delta))
+          def initialize(aggregation_temporality: ENV.fetch('OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE', :delta), is_monotonic: false)
             # TODO: the default should be :cumulative, see issue #1555
             @aggregation_temporality = aggregation_temporality.to_sym
+            @is_monotonic = is_monotonic
           end
 
           def collect(start_time, end_time, data_points)
@@ -47,6 +48,8 @@ def update(increment, attributes, data_points)
               nil
             )
 
+            return if is_monotonic && increment < 0
+
             ndp.value += increment
             nil
           end

metrics_sdk/lib/opentelemetry/sdk/metrics/instrument/counter.rb

@@ -42,7 +42,7 @@ def add(increment, attributes: {})
           private
 
           def default_aggregation
-            OpenTelemetry::SDK::Metrics::Aggregation::Sum.new
+            OpenTelemetry::SDK::Metrics::Aggregation::Sum.new(is_monotonic: true)
           end
         end
       end

metrics_sdk/lib/opentelemetry/sdk/metrics/instrument/up_down_counter.rb

@@ -35,7 +35,7 @@ def add(amount, attributes: {})
           private
 
           def default_aggregation
-            OpenTelemetry::SDK::Metrics::Aggregation::Sum.new
+            OpenTelemetry::SDK::Metrics::Aggregation::Sum.new(is_monotonic: false)
           end
         end
       end

metrics_sdk/lib/opentelemetry/sdk/metrics/state/metric_data.rb

@@ -18,7 +18,8 @@ module State
                                 :data_points,               # Hash{Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>} => Numeric}
                                 :aggregation_temporality,   # Symbol
                                 :start_time_unix_nano,      # Integer nanoseconds since Epoch
-                                :time_unix_nano)            # Integer nanoseconds since Epoch
+                                :time_unix_nano,            # Integer nanoseconds since Epoch
+                                :is_monotonic)              # Boolean
       end
     end
   end

metrics_sdk/lib/opentelemetry/sdk/metrics/state/metric_stream.rb

@@ -67,6 +67,8 @@ def update(value, attributes)
 
           def aggregate_metric_data(start_time, end_time, aggregation: nil)
             aggregator = aggregation || @default_aggregation
+            is_monotonic = aggregator.respond_to?(:is_monotonic) && aggregator.is_monotonic
+
             MetricData.new(
               @name,
               @description,
@@ -77,7 +79,8 @@ def aggregate_metric_data(start_time, end_time, aggregation: nil)
               aggregator.collect(start_time, end_time, @data_points),
               aggregator.aggregation_temporality,
               start_time,
-              end_time
+              end_time,
+              is_monotonic
             )
           end
 

metrics_sdk/test/opentelemetry/sdk/metrics/aggregation/sum_test.rb

@@ -8,8 +8,9 @@
 
 describe OpenTelemetry::SDK::Metrics::Aggregation::Sum do
   let(:data_points) { {} }
-  let(:sum_aggregation) { OpenTelemetry::SDK::Metrics::Aggregation::Sum.new(aggregation_temporality: aggregation_temporality) }
+  let(:sum_aggregation) { OpenTelemetry::SDK::Metrics::Aggregation::Sum.new(aggregation_temporality: aggregation_temporality, is_monotonic: is_monotonic) }
   let(:aggregation_temporality) { :delta }
+  let(:is_monotonic) { false }
 
   # Time in nano
   let(:start_time) { (Time.now.to_r * 1_000_000_000).to_i }
@@ -58,6 +59,14 @@
     _(ndps[1].attributes).must_equal('foo' => 'bar')
   end
 
+  it 'aggregates and collects negative values' do
+    sum_aggregation.update(1, {}, data_points)
+    sum_aggregation.update(-2, {}, data_points)
+
+    ndps = sum_aggregation.collect(start_time, end_time, data_points)
+    _(ndps[0].value).must_equal(-1)
+  end
+
   it 'does not aggregate between collects' do
     sum_aggregation.update(1, {}, data_points)
     sum_aggregation.update(2, {}, data_points)
@@ -94,4 +103,17 @@
       _(ndps[0].value).must_equal(4)
     end
   end
+
+  describe 'when sum type is monotonic' do
+    let(:aggregation_temporality) { :not_delta }
+    let(:is_monotonic) { true }
+
+    it 'does not allow negative values to accumulate' do
+      sum_aggregation.update(1, {}, data_points)
+      sum_aggregation.update(-2, {}, data_points)
+      ndps = sum_aggregation.collect(start_time, end_time, data_points)
+
+      _(ndps[0].value).must_equal(1)
+    end
+  end
 end