opentelemetry-metrics-sdk 0.11.0 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac17345b1f4d2a296aa95591e64264cd7bc03e94b5b6cac35ff0a0067b8a457f
-  data.tar.gz: d22cdd5f1c3f5f0d9745e330874d47c232bb451a986a4304f003e796a598abf7
+  metadata.gz: 0f62ae36ad71651af824a64c15bd3ffff2e32c08cd161655a013955736f97a95
+  data.tar.gz: 7c1a32329e65f2a96e5ee4c6715067cb488e2b5c88e2642d3668d2eddfbe9ce3
 SHA512:
-  metadata.gz: ec0286d37a8a6143b239931c7f68853b5b9d5053ca00da5edfefb665713aef4522995f3ed082674e63c026e99883ef7a59ac7a4dc2b0803d8c17d4a11e4ee58e
-  data.tar.gz: 1ac16f88eec4c62c7efeb494333e2c63d1f55f8d90e027ea9750d76dc7fe72c503fa03c9fa24fc91543e041df2957daf977fe45a7b072e9bdfbe4408312cabf0
+  metadata.gz: 8286d7d68a62f7629e05fbfc7718743b583268a24882f390e60fdcdf584a27dc7aef7d487d209caafd179966c713969334c06fb2ad230f3865686627b62a88ef
+  data.tar.gz: e43fca566da12585f81251e896175a4b627af4403aa9d146d733ebce117cadf08836d1687d01acfe024c7f9ef06a395f3122ba080201249677eb9b154b9bedd9

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Release History: opentelemetry-metrics-sdk
 
+### v0.11.2 / 2025-12-02
+
+* FIXED: Add merge logic for exponential histogram when the temporality cumulative
+
+### v0.11.1 / 2025-11-04
+
+* FIXED: Do not log error when there are no metrics to export
+
 ### v0.11.0 / 2025-10-28
 
 * ADDED: Add logging about export status to Metrics SDK

data/lib/opentelemetry/sdk/metrics/aggregation/exponential_bucket_histogram.rb

@@ -9,6 +9,7 @@ require_relative 'exponential_histogram/log2e_scale_factor'
 require_relative 'exponential_histogram/ieee_754'
 require_relative 'exponential_histogram/logarithm_mapping'
 require_relative 'exponential_histogram/exponent_mapping'
+require_relative 'exponential_histogram_data_point'
 
 module OpenTelemetry
   module SDK
@@ -44,8 +45,20 @@ module OpenTelemetry
             @scale          = validate_scale(max_scale)
 
             @mapping = new_mapping(@scale)
+
+            # Previous state for cumulative aggregation
+            @previous_positive = {} # nil
+            @previous_negative = {} # nil
+            @previous_min = {} # Float::INFINITY
+            @previous_max = {} # -Float::INFINITY
+            @previous_sum = {} # 0
+            @previous_count = {} # 0
+            @previous_zero_count = {} # 0
+            @previous_scale = {} # nil
           end
 
+          # when aggregation temporality is cumulative, merge and downscale will happen.
+          # rubocop:disable Metrics/MethodLength
           def collect(start_time, end_time, data_points)
             if @aggregation_temporality.delta?
               # Set timestamps and 'move' data point values to result.
@@ -57,18 +70,133 @@ module OpenTelemetry
               data_points.clear
               hdps
             else
-              # Update timestamps and take a snapshot.
-              data_points.values.map! do |hdp|
-                hdp.start_time_unix_nano ||= start_time # Start time of a data point is from the first observation.
-                hdp.time_unix_nano = end_time
-                hdp = hdp.dup
-                hdp.positive = hdp.positive.dup
-                hdp.negative = hdp.negative.dup
-                hdp
+              # CUMULATIVE temporality - merge current data_points to previous data_points
+              # and only keep the merged data_points in @previous_*
+
+              merged_data_points = {}
+
+              # this will slow down the operation especially if large amount of data_points present
+              # but it should be fine since with cumulative, the data_points are merged into previous_* and not kept in data_points
+              # rubocop:disable Metrics/BlockLength
+              data_points.each do |attributes, hdp|
+                # Store current values
+                current_positive = hdp.positive
+                current_negative = hdp.negative
+                current_sum = hdp.sum
+                current_min = hdp.min
+                current_max = hdp.max
+                current_count = hdp.count
+                current_zero_count = hdp.zero_count
+                current_scale = hdp.scale
+
+                # Setup previous positive, negative bucket and scale based on three different cases
+                @previous_positive[attributes] = current_positive.copy_empty if @previous_positive[attributes].nil?
+                @previous_negative[attributes] = current_negative.copy_empty if @previous_negative[attributes].nil?
+                @previous_scale[attributes] = current_scale if @previous_scale[attributes].nil?
+
+                # Determine minimum scale for merging
+                min_scale = [@previous_scale[attributes], current_scale].min
+
+                # Calculate ranges for positive and negative buckets
+                low_positive, high_positive = get_low_high_previous_current(
+                  @previous_positive[attributes],
+                  current_positive,
+                  @previous_scale[attributes],
+                  current_scale,
+                  min_scale
+                )
+                low_negative, high_negative = get_low_high_previous_current(
+                  @previous_negative[attributes],
+                  current_negative,
+                  @previous_scale[attributes],
+                  current_scale,
+                  min_scale
+                )
+
+                # Adjust min_scale based on bucket size constraints
+                min_scale = [
+                  min_scale - get_scale_change(low_positive, high_positive),
+                  min_scale - get_scale_change(low_negative, high_negative)
+                ].min
+
+                # Downscale previous buckets if necessary
+                downscale_change = @previous_scale[attributes] - min_scale
+                downscale(downscale_change, @previous_positive[attributes], @previous_negative[attributes])
+
+                # Merge current buckets into previous buckets (kind like update); it's always :cumulative
+                merge_buckets(@previous_positive[attributes], current_positive, current_scale, min_scale, @aggregation_temporality)
+                merge_buckets(@previous_negative[attributes], current_negative, current_scale, min_scale, @aggregation_temporality)
+
+                # initialize min, max, sum, count, zero_count for first time
+                @previous_min[attributes] = Float::INFINITY if @previous_min[attributes].nil?
+                @previous_max[attributes] = -Float::INFINITY if @previous_max[attributes].nil?
+                @previous_sum[attributes] = 0 if @previous_sum[attributes].nil?
+                @previous_count[attributes] = 0 if @previous_count[attributes].nil?
+                @previous_zero_count[attributes] = 0 if @previous_zero_count[attributes].nil?
+
+                # Update aggregated values
+                @previous_min[attributes] = [@previous_min[attributes], current_min].min
+                @previous_max[attributes] = [@previous_max[attributes], current_max].max
+                @previous_sum[attributes] += current_sum
+                @previous_count[attributes] += current_count
+                @previous_zero_count[attributes] += current_zero_count
+                @previous_scale[attributes] = min_scale
+
+                # Create merged data point
+                merged_hdp = ExponentialHistogramDataPoint.new(
+                  attributes,
+                  start_time,
+                  end_time,
+                  @previous_count[attributes],
+                  @previous_sum[attributes],
+                  @previous_scale[attributes],
+                  @previous_zero_count[attributes],
+                  @previous_positive[attributes].dup,
+                  @previous_negative[attributes].dup,
+                  0, # flags
+                  nil, # exemplars
+                  @previous_min[attributes],
+                  @previous_max[attributes],
+                  @zero_threshold
+                )
+
+                merged_data_points[attributes] = merged_hdp
+              end
+              # rubocop:enable Metrics/BlockLength
+
+              # when you have no local_data_points, the loop from cumulative aggregation will not run
+              # so return last merged data points if exists
+              if data_points.empty? && !@previous_positive.empty?
+                @previous_positive.each_key do |attributes|
+                  merged_hdp = ExponentialHistogramDataPoint.new(
+                    attributes,
+                    start_time,
+                    end_time,
+                    @previous_count[attributes],
+                    @previous_sum[attributes],
+                    @previous_scale[attributes],
+                    @previous_zero_count[attributes],
+                    @previous_positive[attributes].dup,
+                    @previous_negative[attributes].dup,
+                    0, # flags
+                    nil, # exemplars
+                    @previous_min[attributes],
+                    @previous_max[attributes],
+                    @zero_threshold
+                  )
+                  merged_data_points[attributes] = merged_hdp
+                end
               end
+
+              # clear data_points since the data is merged into previous_* already;
+              # otherwise we will have duplicated data_points in the next collect
+              data_points.clear
+              merged_data_points.values # return array
             end
           end
+          # rubocop:enable Metrics/MethodLength
 
+          # this is aggregate in python; there is no merge in aggregate; but rescale happened
           # rubocop:disable Metrics/MethodLength
           def update(amount, attributes, data_points)
             # fetch or initialize the ExponentialHistogramDataPoint
@@ -78,6 +206,7 @@ module OpenTelemetry
                 max = -Float::INFINITY
               end
 
+              # this code block will only be executed if no data_points was found with the attributes
               data_points[attributes] = ExponentialHistogramDataPoint.new(
                 attributes,
                 nil,                                                               # :start_time_unix_nano
@@ -203,7 +332,8 @@ module OpenTelemetry
           end
 
           def downscale(change, positive, negative)
-            return if change <= 0
+            return if change == 0
+            raise ArgumentError, 'Invalid change of scale' if change < 0
 
             positive.downscale(change)
             negative.downscale(change)
@@ -217,11 +347,76 @@ module OpenTelemetry
           end
 
           def validate_size(size)
-            raise ArgumentError, "Max size #{size} is smaller than minimum size #{MIN_MAX_SIZE}" if size < MIN_MAX_SIZE
-            raise ArgumentError, "Max size #{size} is larger than maximum size #{MAX_MAX_SIZE}" if size > MAX_MAX_SIZE
+            raise ArgumentError, "Buckets min size #{size} is smaller than minimum min size #{MIN_MAX_SIZE}" if size < MIN_MAX_SIZE
+            raise ArgumentError, "Buckets max size #{size} is larger than maximum max size #{MAX_MAX_SIZE}" if size > MAX_MAX_SIZE
 
             size
           end
+
+          # checked, only issue is if @previous_scale is nil, then get_low_high may throw error
+          def get_low_high_previous_current(previous_buckets, current_buckets, previous_scale, current_scale, min_scale)
+            previous_low, previous_high = get_low_high(previous_buckets, previous_scale, min_scale)
+            current_low, current_high = get_low_high(current_buckets, current_scale, min_scale)
+
+            if current_low > current_high
+              [previous_low, previous_high]
+            elsif previous_low > previous_high
+              [current_low, current_high]
+            else
+              [[previous_low, current_low].min, [previous_high, current_high].max]
+            end
+          end
+
+          def get_low_high(buckets, scale, min_scale)
+            return [0, -1] if buckets.nil? || buckets.counts == [0] || buckets.counts.empty?
+
+            shift = scale - min_scale
+            [buckets.index_start >> shift, buckets.index_end >> shift]
+          end
+
+          def merge_buckets(previous_buckets, current_buckets, current_scale, min_scale, aggregation_temporality)
+            return unless current_buckets && !current_buckets.counts.empty?
+
+            current_change = current_scale - min_scale
+
+            # when we iterate counts, we don't use offset counts
+            current_buckets.instance_variable_get(:@counts).each_with_index do |current_bucket, current_bucket_index|
+              next if current_bucket == 0
+
+              current_index = current_buckets.index_base + current_bucket_index
+              current_index -= current_buckets.counts.size if current_index > current_buckets.index_end
+
+              inds = current_index >> current_change
+
+              # Grow previous buckets if needed to accommodate the new index
+              if inds < previous_buckets.index_start
+                span = previous_buckets.index_end - inds
+
+                raise StandardError, 'Incorrect merge scale' if span >= @size
+
+                previous_buckets.grow(span + 1, @size) if span >= previous_buckets.counts.size
+
+                previous_buckets.index_start = inds
+              end
+
+              if inds > previous_buckets.index_end
+                span = inds - previous_buckets.index_start
+
+                raise StandardError, 'Incorrect merge scale' if span >= @size
+
+                previous_buckets.grow(span + 1, @size) if span >= previous_buckets.counts.size
+
+                previous_buckets.index_end = inds
+              end
+
+              bucket_index = inds - previous_buckets.index_base
+              bucket_index += previous_buckets.counts.size if bucket_index < 0
+
+              # For delta temporality in merge, we subtract (this shouldn't normally happen in our use case)
+              increment = aggregation_temporality == :delta ? -current_bucket : current_bucket
+              previous_buckets.increment_bucket(bucket_index, increment)
+            end
+          end
         end
       end
     end

data/lib/opentelemetry/sdk/metrics/aggregation/exponential_histogram/buckets.rb

@@ -27,7 +27,6 @@ module OpenTelemetry
               old_positive_limit = size - bias
 
               new_size = [2**Math.log2(needed).ceil, max_size].min
-
               new_positive_limit = new_size - bias
 
               tmp = Array.new(new_size, 0)
@@ -105,6 +104,15 @@ module OpenTelemetry
             def increment_bucket(bucket_index, increment = 1)
               @counts[bucket_index] += increment
             end
+
+            def copy_empty
+              new_buckets = self.class.new
+              new_buckets.instance_variable_set(:@counts, Array.new(@counts.size, 0))
+              new_buckets.instance_variable_set(:@index_base, @index_base)
+              new_buckets.instance_variable_set(:@index_start, @index_start)
+              new_buckets.instance_variable_set(:@index_end, @index_end)
+              new_buckets
+            end
           end
         end
       end

data/lib/opentelemetry/sdk/metrics/export/periodic_metric_reader.rb

@@ -130,12 +130,7 @@ module OpenTelemetry
           end
 
           def report_result(result_code)
-            if result_code == Export::SUCCESS
-              OpenTelemetry.logger.debug 'Successfully exported metrics'
-            else
-              OpenTelemetry.handle_error(exception: ExportError.new('Unable to export metrics'))
-              OpenTelemetry.logger.error("Result code: #{result_code}")
-            end
+            OpenTelemetry.logger.debug 'Successfully exported metrics' if result_code == Export::SUCCESS
           end
 
           def lock(&block)

data/lib/opentelemetry/sdk/metrics/state/asynchronous_metric_stream.rb

@@ -56,7 +56,7 @@ module OpenTelemetry
                 end
               end
             else
-              @registered_views.each do |view|
+              @registered_views.each do |view, data_points|
                 @mutex.synchronize do
                   @callback.each do |cb|
                     value = safe_guard_callback(cb, timeout: timeout)
@@ -64,7 +64,7 @@ module OpenTelemetry
 
                     merged_attributes = attributes || {}
                     merged_attributes.merge!(view.attribute_keys)
-                    view.aggregation.update(value, merged_attributes, @data_points) if view.valid_aggregation?
+                    view.aggregation.update(value, merged_attributes, data_points) if view.valid_aggregation?
                   end
                 end
               end
@@ -78,19 +78,19 @@ module OpenTelemetry
             thread = Thread.new do
               result = callback.call
             rescue StandardError => e
-              OpenTelemetry.logger.error("Error invoking callback: #{e.message}")
+              OpenTelemetry.handle_error(exception: e, message: 'Error invoking callback.')
               result = :error
             end
 
             unless thread.join(timeout)
               thread.kill
-              OpenTelemetry.logger.error("Timeout while invoking callback after #{timeout} seconds")
+              OpenTelemetry.handle_error(message: "Timeout while invoking callback after #{timeout} seconds")
               return nil
             end
 
             result == :error ? nil : result
           rescue StandardError => e
-            OpenTelemetry.logger.error("Unexpected error in callback execution: #{e.message}")
+            OpenTelemetry.handle_error(exception: e, message: 'Unexpected error in callback execution.')
             nil
           end
         end

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

@@ -32,7 +32,7 @@ module OpenTelemetry
             @instrumentation_scope = instrumentation_scope
             @default_aggregation = aggregation
             @data_points = {}
-            @registered_views = []
+            @registered_views = {}
 
             find_registered_view
             @mutex = Mutex.new
@@ -43,12 +43,14 @@ module OpenTelemetry
               metric_data = []
 
               # data points are required to export over OTLP
-              return metric_data if @data_points.empty?
+              return metric_data if empty_data_point?
 
               if @registered_views.empty?
                 metric_data << aggregate_metric_data(start_time, end_time)
               else
-                @registered_views.each { |view| metric_data << aggregate_metric_data(start_time, end_time, aggregation: view.aggregation) }
+                @registered_views.each do |view, data_points|
+                  metric_data << aggregate_metric_data(start_time, end_time, aggregation: view.aggregation, data_points: data_points)
+                end
               end
 
               metric_data
@@ -60,20 +62,21 @@ module OpenTelemetry
             if @registered_views.empty?
               @mutex.synchronize { @default_aggregation.update(value, attributes, @data_points) }
             else
-              @registered_views.each do |view|
+              @registered_views.each do |view, data_points|
                 @mutex.synchronize do
                   attributes ||= {}
                   attributes.merge!(view.attribute_keys)
-                  view.aggregation.update(value, attributes, @data_points) if view.valid_aggregation?
+                  view.aggregation.update(value, attributes, data_points) if view.valid_aggregation?
                 end
               end
             end
           end
 
-          def aggregate_metric_data(start_time, end_time, aggregation: nil)
+          def aggregate_metric_data(start_time, end_time, aggregation: nil, data_points: nil)
             aggregator = aggregation || @default_aggregation
             is_monotonic = aggregator.respond_to?(:monotonic?) ? aggregator.monotonic? : nil
             aggregation_temporality = aggregator.respond_to?(:aggregation_temporality) ? aggregator.aggregation_temporality : nil
+            data_point = data_points || @data_points
 
             MetricData.new(
               @name,
@@ -82,7 +85,7 @@ module OpenTelemetry
               @instrument_kind,
               @meter_provider.resource,
               @instrumentation_scope,
-              aggregator.collect(start_time, end_time, @data_points),
+              aggregator.collect(start_time, end_time, data_point),
               aggregation_temporality,
               start_time,
               end_time,
@@ -93,7 +96,17 @@ module OpenTelemetry
           def find_registered_view
             return if @meter_provider.nil?
 
-            @meter_provider.registered_views.each { |view| @registered_views << view if view.match_instrument?(self) }
+            @meter_provider.registered_views.each { |view| @registered_views[view] = {} if view.match_instrument?(self) }
+          end
+
+          def empty_data_point?
+            if @registered_views.empty?
+              @data_points.empty?
+            else
+              @registered_views.each_value do |data_points|
+                return false unless data_points.empty?
+              end
+            end
           end
 
           def to_s

data/lib/opentelemetry/sdk/metrics/version.rb

@@ -8,7 +8,7 @@ module OpenTelemetry
   module SDK
     module Metrics
       # Current OpenTelemetry metrics sdk version
-      VERSION = '0.11.0'
+      VERSION = '0.11.2'
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-metrics-sdk
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.2
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-28 00:00:00.000000000 Z
+date: 2025-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -251,10 +251,10 @@ homepage: https://github.com/open-telemetry/opentelemetry-ruby
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-metrics-sdk/v0.11.0/file.CHANGELOG.html
+  changelog_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-metrics-sdk/v0.11.2/file.CHANGELOG.html
   source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby/tree/main/metrics_sdk
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby/issues
-  documentation_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-metrics-sdk/v0.11.0
+  documentation_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-metrics-sdk/v0.11.2
 post_install_message:
 rdoc_options: []
 require_paths: