opentelemetry-metrics-sdk 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a74df1307dfb40dbdaf08d87781c35d2736916d94ae06eef45b3237b3ba38631
-  data.tar.gz: 3a108b46150f768890f6cef2acd49557d83331cc4a84613b8c7de38861cfebdb
+  metadata.gz: 4ad774f1262340ffa611f512b97fa605e92857ce72262bcdf7c60edc96a4d61e
+  data.tar.gz: 5be962ef2df37a6202e3fc99d5efca5846572824568cca61f33beb121daabb7b
 SHA512:
-  metadata.gz: 2b168a69a35cee4b798cf9195b0af540d79b2b9cbb687dd98abe295a517e38683fce1976a7028ab822f8e5aec3157b53043ed9ddbb436cf5a2f25101ddc50b61
-  data.tar.gz: a06ace144467243b00a4d19bec891d66d55f3da2c611d4569e393b805d31979ab47eed39dbb86d4b9d508519b69ce2f827acb3281c446d83fe8201a6e84150fe
+  metadata.gz: '09a50b41250b9cbbc69a1d64a19652d9b4bac203f5111b0c9a794d4a15aac0327a67ac846a65cc083ae908dde4c3766d6cb65838b8d1af81b0d33bfac9e41ec4'
+  data.tar.gz: dc20ca5183f8423e32dcfb2b7dc810212f19ae2ac59a2026015983381662b388673540df3427a479a81c83756330aac4ce27e95161a50f239d8470fb6c6a4aea

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Release History: opentelemetry-metrics-sdk
 
+### v0.7.0 / 2025-05-13
+
+* ADDED: Add basic exponential histogram
+
+### v0.6.1 / 2025-04-09
+
+* FIXED: Use condition signal to replace sleep and remove timeout.timeout…
+
 ### v0.6.0 / 2025-02-25
 
 - ADDED: Support 3.1 Min Version

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

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require_relative 'exponential_histogram/buckets'
+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'
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Aggregation
+        # Contains the implementation of the {https://opentelemetry.io/docs/specs/otel/metrics/data-model/#exponentialhistogram ExponentialBucketHistogram} aggregation
+        class ExponentialBucketHistogram # rubocop:disable Metrics/ClassLength
+          attr_reader :aggregation_temporality
+
+          # relate to min max scale: https://opentelemetry.io/docs/specs/otel/metrics/sdk/#support-a-minimum-and-maximum-scale
+          MAX_SCALE = 20
+          MIN_SCALE = -10
+          MAX_SIZE  = 160
+
+          # The default boundaries are calculated based on default max_size and max_scale values
+          def initialize(
+            aggregation_temporality: ENV.fetch('OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE', :delta),
+            max_size: MAX_SIZE,
+            max_scale: MAX_SCALE,
+            record_min_max: true,
+            zero_threshold: 0
+          )
+            @aggregation_temporality = aggregation_temporality
+            @record_min_max = record_min_max
+            @min            = Float::INFINITY
+            @max            = -Float::INFINITY
+            @sum            = 0
+            @count          = 0
+            @zero_threshold = zero_threshold
+            @zero_count     = 0
+            @size           = validate_size(max_size)
+            @scale          = validate_scale(max_scale)
+
+            @mapping = new_mapping(@scale)
+          end
+
+          def collect(start_time, end_time, data_points)
+            if @aggregation_temporality == :delta
+              # Set timestamps and 'move' data point values to result.
+              hdps = data_points.values.map! do |hdp|
+                hdp.start_time_unix_nano = start_time
+                hdp.time_unix_nano = end_time
+                hdp
+              end
+              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
+              end
+            end
+          end
+
+          # rubocop:disable Metrics/MethodLength
+          def update(amount, attributes, data_points)
+            # fetch or initialize the ExponentialHistogramDataPoint
+            hdp = data_points.fetch(attributes) do
+              if @record_min_max
+                min = Float::INFINITY
+                max = -Float::INFINITY
+              end
+
+              data_points[attributes] = ExponentialHistogramDataPoint.new(
+                attributes,
+                nil,                                                               # :start_time_unix_nano
+                0,                                                                 # :time_unix_nano
+                0,                                                                 # :count
+                0,                                                                 # :sum
+                @scale,                                                            # :scale
+                @zero_count,                                                       # :zero_count
+                ExponentialHistogram::Buckets.new,  # :positive
+                ExponentialHistogram::Buckets.new,  # :negative
+                0,                                                                 # :flags
+                nil,                                                               # :exemplars
+                min,                                                               # :min
+                max,                                                               # :max
+                @zero_threshold # :zero_threshold)
+              )
+            end
+
+            # Start to populate the data point (esp. the buckets)
+            if @record_min_max
+              hdp.max = amount if amount > hdp.max
+              hdp.min = amount if amount < hdp.min
+            end
+
+            hdp.sum += amount
+            hdp.count += 1
+
+            if amount.abs <= @zero_threshold
+              hdp.zero_count += 1
+              hdp.scale = 0 if hdp.count == hdp.zero_count # if always getting zero, then there is no point to keep doing the update
+              return
+            end
+
+            # rescale, map to index, update the buckets here
+            buckets = amount.positive? ? hdp.positive : hdp.negative
+            amount = -amount if amount.negative?
+
+            bucket_index = @mapping.map_to_index(amount)
+
+            rescaling_needed = false
+            low = high = 0
+
+            if buckets.counts == [0] # special case of empty
+              buckets.index_start = bucket_index
+              buckets.index_end   = bucket_index
+              buckets.index_base  = bucket_index
+
+            elsif bucket_index < buckets.index_start && (buckets.index_end - bucket_index) >= @size
+              rescaling_needed = true
+              low = bucket_index
+              high = buckets.index_end
+
+            elsif bucket_index > buckets.index_end && (bucket_index - buckets.index_start) >= @size
+              rescaling_needed = true
+              low = buckets.index_start
+              high = bucket_index
+            end
+
+            if rescaling_needed
+              scale_change = get_scale_change(low, high)
+              downscale(scale_change, hdp.positive, hdp.negative)
+              new_scale = @mapping.scale - scale_change
+              hdp.scale = new_scale
+              @mapping = new_mapping(new_scale)
+              bucket_index = @mapping.map_to_index(amount)
+
+              OpenTelemetry.logger.debug "Rescaled with new scale #{new_scale} from #{low} and #{high}; bucket_index is updated to #{bucket_index}"
+            end
+
+            # adjust buckets based on the bucket_index
+            if bucket_index < buckets.index_start
+              span = buckets.index_end - bucket_index
+              grow_buckets(span, buckets)
+              buckets.index_start = bucket_index
+            elsif bucket_index > buckets.index_end
+              span = bucket_index - buckets.index_start
+              grow_buckets(span, buckets)
+              buckets.index_end = bucket_index
+            end
+
+            bucket_index -= buckets.index_base
+            bucket_index += buckets.counts.size if bucket_index.negative?
+
+            buckets.increment_bucket(bucket_index)
+            nil
+          end
+          # rubocop:enable Metrics/MethodLength
+
+          private
+
+          def grow_buckets(span, buckets)
+            return if span < buckets.counts.size
+
+            OpenTelemetry.logger.debug "buckets need to grow to #{span + 1} from #{buckets.counts.size} (max bucket size #{@size})"
+            buckets.grow(span + 1, @size)
+          end
+
+          def new_mapping(scale)
+            scale <= 0 ? ExponentialHistogram::ExponentMapping.new(scale) : ExponentialHistogram::LogarithmMapping.new(scale)
+          end
+
+          def empty_counts
+            @boundaries ? Array.new(@boundaries.size + 1, 0) : nil
+          end
+
+          def get_scale_change(low, high)
+            # puts "get_scale_change: low: #{low}, high: #{high}, @size: #{@size}"
+            # python code also produce 18 with 0,1048575, the high is little bit off
+            # just checked, the mapping is also ok, produce the 1048575
+            change = 0
+            while high - low >= @size
+              high >>= 1
+              low >>= 1
+              change += 1
+            end
+            change
+          end
+
+          def downscale(change, positive, negative)
+            return if change <= 0
+
+            positive.downscale(change)
+            negative.downscale(change)
+          end
+
+          def validate_scale(scale)
+            return scale unless scale > MAX_SCALE || scale < MIN_SCALE
+
+            OpenTelemetry.logger.warn "Scale #{scale} is invalid, using default max scale #{MAX_SCALE}"
+            MAX_SCALE
+          end
+
+          def validate_size(size)
+            return size unless size > MAX_SIZE || size < 0
+
+            OpenTelemetry.logger.warn "Size #{size} is invalid, using default max size #{MAX_SIZE}"
+            MAX_SIZE
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Aggregation
+        module ExponentialHistogram
+          # Buckets is the fundamental building block of exponential histogram that store bucket/boundary value
+          class Buckets
+            attr_accessor :index_start, :index_end, :index_base
+
+            def initialize
+              @counts = [0]
+              @index_base = 0
+              @index_start = 0
+              @index_end = 0
+            end
+
+            # grow simply expand the @counts size
+            def grow(needed, max_size)
+              size = @counts.size
+              bias = @index_base - @index_start
+              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)
+              tmp[new_positive_limit..-1] = @counts[old_positive_limit..]
+              tmp[0...old_positive_limit] = @counts[0...old_positive_limit]
+              @counts = tmp
+            end
+
+            def offset
+              @index_start
+            end
+
+            def offset_counts
+              bias = @index_base - @index_start
+              @counts[-bias..] + @counts[0...-bias]
+            end
+            alias counts offset_counts
+
+            def length
+              return 0 if @counts.empty?
+              return 0 if @index_end == @index_start && counts[0] == 0
+
+              @index_end - @index_start + 1
+            end
+
+            def get_bucket(key)
+              bias = @index_base - @index_start
+
+              key += @counts.size if key < bias
+              key -= bias
+
+              @counts[key]
+            end
+
+            def downscale(amount)
+              bias = @index_base - @index_start
+
+              if bias != 0
+                @index_base = @index_start
+                @counts.reverse!
+                @counts = @counts[0...bias].reverse + @counts[bias..].reverse
+              end
+
+              size = 1 + @index_end - @index_start
+              each = 1 << amount
+              inpos = 0
+              outpos = 0
+              pos = @index_start
+
+              while pos <= @index_end
+                mod = pos % each
+                mod += each if mod < 0
+
+                inds = mod
+
+                while inds < each && inpos < size
+                  if outpos != inpos
+                    @counts[outpos] += @counts[inpos]
+                    @counts[inpos] = 0
+                  end
+
+                  inpos += 1
+                  pos   += 1
+                  inds  += 1
+                end
+
+                outpos += 1
+              end
+
+              @index_start >>= amount
+              @index_end >>= amount
+              @index_base = @index_start
+            end
+
+            def increment_bucket(bucket_index, increment = 1)
+              @counts[bucket_index] += increment
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Aggregation
+        module ExponentialHistogram
+          # LogarithmMapping for mapping when scale < 0
+          class ExponentMapping
+            attr_reader :scale
+
+            def initialize(scale)
+              @scale = scale
+              @min_normal_lower_boundary_index = calculate_min_normal_lower_boundary_index(scale)
+              @max_normal_lower_boundary_index = IEEE754::MAX_NORMAL_EXPONENT >> -@scale
+            end
+
+            def map_to_index(value)
+              return @min_normal_lower_boundary_index if value < IEEE754::MIN_NORMAL_VALUE
+
+              exponent = IEEE754.get_ieee_754_exponent(value)
+              correction = (IEEE754.get_ieee_754_mantissa(value) - 1) >> IEEE754::MANTISSA_WIDTH
+              (exponent + correction) >> -@scale
+            end
+
+            def calculate_min_normal_lower_boundary_index(scale)
+              inds = IEEE754::MIN_NORMAL_EXPONENT >> -scale
+              inds -= 1 if -scale < 2
+              inds
+            end
+
+            # for testing
+            def get_lower_boundary(inds)
+              raise StandardError, 'mapping underflow' if inds < @min_normal_lower_boundary_index || inds > @max_normal_lower_boundary_index
+
+              Math.ldexp(1, inds << -@scale)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Aggregation
+        module ExponentialHistogram
+          # IEEE754 standard for floating-point calculation
+          module IEEE754
+            MANTISSA_WIDTH = 52
+            EXPONENT_WIDTH = 11
+
+            MANTISSA_MASK = (1 << MANTISSA_WIDTH) - 1
+            EXPONENT_BIAS = (2**(EXPONENT_WIDTH - 1)) - 1
+            EXPONENT_MASK = ((1 << EXPONENT_WIDTH) - 1) << MANTISSA_WIDTH
+            SIGN_MASK = 1 << (EXPONENT_WIDTH + MANTISSA_WIDTH)
+
+            MIN_NORMAL_EXPONENT = -EXPONENT_BIAS + 1
+            MAX_NORMAL_EXPONENT = EXPONENT_BIAS
+
+            MIN_NORMAL_VALUE = Float::MIN
+            MAX_NORMAL_VALUE = Float::MAX
+
+            def self.get_ieee_754_exponent(value)
+              bits = [value].pack('d').unpack1('Q')
+              ((bits & EXPONENT_MASK) >> MANTISSA_WIDTH) - EXPONENT_BIAS
+            end
+
+            def self.get_ieee_754_mantissa(value)
+              bits = [value].pack('d').unpack1('Q')
+              bits & MANTISSA_MASK
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Aggregation
+        module ExponentialHistogram
+          # Log2eScaleFactor is precomputed scale factor value
+          class Log2eScaleFactor
+            MAX_SCALE = 20
+
+            LOG2E_SCALE_BUCKETS = (0..MAX_SCALE).map do |scale|
+              log2e = 1 / Math.log(2)
+              Math.ldexp(log2e, scale)
+            end
+
+            # for testing
+            def self.log2e_scale_buckets
+              LOG2E_SCALE_BUCKETS
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Aggregation
+        module ExponentialHistogram
+          # LogarithmMapping for mapping when scale > 0
+          class LogarithmMapping
+            attr_reader :scale
+
+            def initialize(scale)
+              @scale = scale
+              @scale_factor = Log2eScaleFactor::LOG2E_SCALE_BUCKETS[scale] # scale_factor is used for mapping the index
+              @min_normal_lower_boundary_index = IEEE754::MIN_NORMAL_EXPONENT << @scale
+              @max_normal_lower_boundary_index = ((IEEE754::MAX_NORMAL_EXPONENT + 1) << @scale) - 1
+            end
+
+            def map_to_index(value)
+              return @min_normal_lower_boundary_index - 1 if value <= IEEE754::MIN_NORMAL_VALUE
+
+              if IEEE754.get_ieee_754_mantissa(value) == 0
+                exponent = IEEE754.get_ieee_754_exponent(value)
+                return (exponent << @scale) - 1
+              end
+
+              [(Math.log(value) * @scale_factor).floor, @max_normal_lower_boundary_index].min
+            end
+
+            # for testing
+            def get_lower_boundary(inds)
+              if inds >= @max_normal_lower_boundary_index
+                return 2 * Math.exp((inds - (1 << @scale)) / @scale_factor) if inds == @max_normal_lower_boundary_index
+
+                raise StandardError, 'mapping overflow'
+              end
+
+              if inds <= @min_normal_lower_boundary_index
+                return IEEE754::MIN_NORMAL_VALUE if inds == @min_normal_lower_boundary_index
+                return Math.exp((inds + (1 << @scale)) / @scale_factor) / 2 if inds == @min_normal_lower_boundary_index - 1
+
+                raise StandardError, 'mapping underflow'
+              end
+
+              Math.exp(inds / @scale_factor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Aggregation
+        # rubocop:disable Lint/StructNewOverride
+
+        ExponentialHistogramDataPoint = Struct.new(:attributes, # optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}
+                                                   :start_time_unix_nano,   # Integer nanoseconds since Epoch
+                                                   :time_unix_nano,         # Integer nanoseconds since Epoch
+                                                   :count,                  # Integer count is the number of values in the population. Must be non-negative
+                                                   :sum,                    # Integer sum of the values in the population. If count is zero then this field then this field must be zero
+                                                   :scale,                  # Integer scale factor
+                                                   :zero_count,             # Integer special bucket that count of observations that fall into the zero bucket
+                                                   :positive,               # Buckets representing the positive range of the histogram.
+                                                   :negative,               # Buckets representing the negative range of the histogram.
+                                                   :flags,                  # Integer flags associated with the data point.
+                                                   :exemplars,              # optional List of exemplars collected from measurements that were used to form the data point
+                                                   :min,                    # optional Float min is the minimum value over (start_time, end_time].
+                                                   :max,                    # optional Float max is the maximum value over (start_time, end_time].
+                                                   :zero_threshold)         # optional Float the threshold for the zero bucket
+        # rubocop:enable Lint/StructNewOverride
+      end
+    end
+  end
+end

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

@@ -21,3 +21,5 @@ require 'opentelemetry/sdk/metrics/aggregation/explicit_bucket_histogram'
 require 'opentelemetry/sdk/metrics/aggregation/sum'
 require 'opentelemetry/sdk/metrics/aggregation/last_value'
 require 'opentelemetry/sdk/metrics/aggregation/drop'
+require 'opentelemetry/sdk/metrics/aggregation/exponential_histogram_data_point'
+require 'opentelemetry/sdk/metrics/aggregation/exponential_bucket_histogram'

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

@@ -33,14 +33,22 @@ module OpenTelemetry
             @thread   = nil
             @continue = false
             @mutex = Mutex.new
+            @condition = ConditionVariable.new
             @export_mutex = Mutex.new
 
             start
           end
 
+          # Shuts the @thread down and set @continue to false; it will block
+          # until the shutdown thread is finished.
+          #
+          # @param [optional Numeric] timeout An optional timeout in seconds.
+          # @return [Integer] SUCCESS if no error occurred, FAILURE if a
+          #   non-specific failure occurred.
           def shutdown(timeout: nil)
             thread = lock do
               @continue = false # force termination in next iteration
+              @condition.signal
               @thread
             end
             thread&.join(@export_interval)
@@ -52,15 +60,35 @@ module OpenTelemetry
             Export::FAILURE
           end
 
+          # Export all metrics to the configured `Exporter` that have not yet
+          # been exported.
+          #
+          # This method should only be called in cases where it is absolutely
+          # necessary, such as when using some FaaS providers that may suspend
+          # the process after an invocation, but before the `PeriodicMetricReader` exports
+          # the completed metrics.
+          #
+          # @param [optional Numeric] timeout An optional timeout in seconds.
+          # @return [Integer] SUCCESS if no error occurred, FAILURE if a
+          #   non-specific failure occurred.
           def force_flush(timeout: nil)
-            export(timeout: timeout)
+            export(timeout:)
             Export::SUCCESS
           rescue StandardError
             Export::FAILURE
           end
 
+          # Check both @thread and @continue object to determine if current
+          # PeriodicMetricReader is still alive. If one of them is true/alive,
+          # then PeriodicMetricReader is determined as alive
+          def alive?
+            @continue || @thread.alive?
+          end
+
           private
 
+          # Start a thread that continously export metrics within fixed duration.
+          # The wait mechanism is using to check @mutex lock with conditional variable
           def start
             @continue = true
             if @exporter.nil?
@@ -70,19 +98,21 @@ module OpenTelemetry
             else
               @thread = Thread.new do
                 while @continue
-                  sleep(@export_interval)
-                  begin
-                    Timeout.timeout(@export_timeout) do
-                      export(timeout: @export_timeout)
-                    end
-                  rescue Timeout::Error => e
-                    OpenTelemetry.handle_error(exception: e, message: 'PeriodicMetricReader timeout.')
+                  lock do
+                    @condition.wait(@mutex, @export_interval)
+                    export(timeout: @export_timeout)
                   end
                 end
               end
             end
           end
 
+          # Helper function for the defined exporter to export metrics.
+          # It only exports if the collected metrics are not an empty array (collect returns an Array).
+          #
+          # @param [optional Numeric] timeout An optional timeout in seconds.
+          # @return [Integer] SUCCESS if no error occurred, FAILURE if a
+          #   non-specific failure occurred
           def export(timeout: nil)
             @export_mutex.synchronize do
               collected_metrics = collect

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

@@ -91,12 +91,12 @@ module OpenTelemetry
           end
 
           def to_s
-            instrument_info = String.new
+            instrument_info = +''
             instrument_info << "name=#{@name}"
             instrument_info << " description=#{@description}" if @description
             instrument_info << " unit=#{@unit}" if @unit
             @data_points.map do |attributes, value|
-              metric_stream_string = String.new
+              metric_stream_string = +''
               metric_stream_string << instrument_info
               metric_stream_string << " attributes=#{attributes}" if attributes
               metric_stream_string << " #{value}"

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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-metrics-sdk
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-25 00:00:00.000000000 Z
+date: 2025-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -208,6 +208,13 @@ files:
 - lib/opentelemetry/sdk/metrics/aggregation.rb
 - lib/opentelemetry/sdk/metrics/aggregation/drop.rb
 - lib/opentelemetry/sdk/metrics/aggregation/explicit_bucket_histogram.rb
+- lib/opentelemetry/sdk/metrics/aggregation/exponential_bucket_histogram.rb
+- lib/opentelemetry/sdk/metrics/aggregation/exponential_histogram/buckets.rb
+- lib/opentelemetry/sdk/metrics/aggregation/exponential_histogram/exponent_mapping.rb
+- lib/opentelemetry/sdk/metrics/aggregation/exponential_histogram/ieee_754.rb
+- lib/opentelemetry/sdk/metrics/aggregation/exponential_histogram/log2e_scale_factor.rb
+- lib/opentelemetry/sdk/metrics/aggregation/exponential_histogram/logarithm_mapping.rb
+- lib/opentelemetry/sdk/metrics/aggregation/exponential_histogram_data_point.rb
 - lib/opentelemetry/sdk/metrics/aggregation/histogram_data_point.rb
 - lib/opentelemetry/sdk/metrics/aggregation/last_value.rb
 - lib/opentelemetry/sdk/metrics/aggregation/number_data_point.rb
@@ -240,10 +247,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.6.0/file.CHANGELOG.html
+  changelog_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-metrics-sdk/v0.7.0/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.6.0
+  documentation_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-metrics-sdk/v0.7.0
 post_install_message:
 rdoc_options: []
 require_paths: