opentelemetry-metrics-sdk 0.1.0

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Export
+        # The InMemoryMetricPullExporter behaves as a Metric Reader and Exporter.
+        # To be used for testing purposes, not production.
+        class InMemoryMetricPullExporter < MetricReader
+          attr_reader :metric_snapshots
+
+          def initialize
+            super
+            @metric_snapshots = []
+            @mutex = Mutex.new
+          end
+
+          def pull
+            export(collect)
+          end
+
+          def export(metrics)
+            @mutex.synchronize do
+              @metric_snapshots << metrics
+            end
+            SUCCESS
+          end
+
+          def reset
+            @mutex.synchronize do
+              @metric_snapshots.clear
+            end
+          end
+
+          def shutdown
+            SUCCESS
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Export
+        # MetricReader provides a minimal example implementation.
+        # It is not required to subclass this class to provide an implementation
+        # of MetricReader, provided the interface is satisfied.
+        class MetricReader
+          attr_reader :metric_store
+
+          def initialize
+            @metric_store = OpenTelemetry::SDK::Metrics::State::MetricStore.new
+          end
+
+          def collect
+            @metric_store.collect
+          end
+
+          def shutdown(timeout: nil)
+            Export::SUCCESS
+          end
+
+          def force_flush(timeout: nil)
+            Export::SUCCESS
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Export
+        ExportError = Class.new(OpenTelemetry::Error)
+
+        # The operation finished successfully.
+        SUCCESS = 0
+
+        # The operation finished with an error.
+        FAILURE = 1
+
+        # The operation timed out.
+        TIMEOUT = 2
+      end
+    end
+  end
+end
+
+require 'opentelemetry/sdk/metrics/export/metric_reader'
+require 'opentelemetry/sdk/metrics/export/in_memory_metric_pull_exporter'
+require 'opentelemetry/sdk/metrics/export/console_metric_pull_exporter'

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Instrument
+        # {Counter} is the SDK implementation of {OpenTelemetry::Metrics::Counter}.
+        class Counter < OpenTelemetry::SDK::Metrics::Instrument::SynchronousInstrument
+          # Returns the instrument kind as a Symbol
+          #
+          # @return [Symbol]
+          def instrument_kind
+            :counter
+          end
+
+          # Increment the Counter by a fixed amount.
+          #
+          # @param [numeric] increment The increment amount, which MUST be a non-negative numeric value.
+          # @param [Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}] attributes
+          #   Values must be non-nil and (array of) string, boolean or numeric type.
+          #   Array values must not contain nil elements and all elements must be of
+          #   the same basic type (string, numeric, boolean).
+          def add(increment, attributes: {})
+            # TODO: When the metrics SDK stabilizes and is merged into the main SDK,
+            # we can leverage the SDK Internal validation classes to enforce this:
+            # https://github.com/open-telemetry/opentelemetry-ruby/blob/6bec625ef49004f364457c26263df421526b60d6/sdk/lib/opentelemetry/sdk/internal.rb#L47
+            if increment.negative?
+              OpenTelemetry.logger.warn("#{@name} received a negative value")
+            else
+              update(increment, attributes)
+            end
+            nil
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+            nil
+          end
+
+          private
+
+          def default_aggregation
+            OpenTelemetry::SDK::Metrics::Aggregation::Sum.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/metrics/instrument/histogram.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Instrument
+        # {Histogram} is the SDK implementation of {OpenTelemetry::Metrics::Histogram}.
+        class Histogram < OpenTelemetry::SDK::Metrics::Instrument::SynchronousInstrument
+          # Returns the instrument kind as a Symbol
+          #
+          # @return [Symbol]
+          def instrument_kind
+            :histogram
+          end
+
+          # Updates the statistics with the specified amount.
+          #
+          # @param [numeric] amount The amount of the Measurement, which MUST be a non-negative numeric value.
+          # @param [Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}] attributes
+          #   Values must be non-nil and (array of) string, boolean or numeric type.
+          #   Array values must not contain nil elements and all elements must be of
+          #   the same basic type (string, numeric, boolean).
+          def record(amount, attributes: nil)
+            update(amount, attributes)
+            nil
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+            nil
+          end
+
+          private
+
+          def default_aggregation
+            OpenTelemetry::SDK::Metrics::Aggregation::ExplicitBucketHistogram.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/metrics/instrument/observable_counter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Instrument
+        # {ObservableCounter} is the SDK implementation of {OpenTelemetry::Metrics::ObservableCounter}.
+        class ObservableCounter < OpenTelemetry::Metrics::Instrument::ObservableCounter
+          attr_reader :name, :unit, :description
+
+          def initialize(name, unit, description, callback, meter)
+            @name = name
+            @unit = unit
+            @description = description
+            @callback = callback
+            @meter = meter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/metrics/instrument/observable_gauge.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Instrument
+        # {ObservableGauge} is the SDK implementation of {OpenTelemetry::Metrics::ObservableGauge}.
+        class ObservableGauge < OpenTelemetry::Metrics::Instrument::ObservableGauge
+          attr_reader :name, :unit, :description
+
+          def initialize(name, unit, description, callback, meter)
+            @name = name
+            @unit = unit
+            @description = description
+            @callback = callback
+            @meter = meter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/metrics/instrument/observable_up_down_counter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Instrument
+        # {ObservableUpDownCounter} is the SDK implementation of {OpenTelemetry::Metrics::ObservableUpDownCounter}.
+        class ObservableUpDownCounter < OpenTelemetry::Metrics::Instrument::ObservableUpDownCounter
+          attr_reader :name, :unit, :description
+
+          def initialize(name, unit, description, callback, meter)
+            @name = name
+            @unit = unit
+            @description = description
+            @callback = callback
+            @meter = meter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/metrics/instrument/synchronous_instrument.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Instrument
+        # {SynchronousInstrument} contains the common functionality shared across
+        # the synchronous instruments SDK instruments.
+        class SynchronousInstrument
+          def initialize(name, unit, description, instrumentation_scope, meter_provider)
+            @name = name
+            @unit = unit
+            @description = description
+            @instrumentation_scope = instrumentation_scope
+            @meter_provider = meter_provider
+            @metric_streams = []
+
+            meter_provider.register_synchronous_instrument(self)
+          end
+
+          # @api private
+          def register_with_new_metric_store(metric_store, aggregation: default_aggregation)
+            ms = OpenTelemetry::SDK::Metrics::State::MetricStream.new(
+              @name,
+              @description,
+              @unit,
+              instrument_kind,
+              @meter_provider,
+              @instrumentation_scope,
+              aggregation
+            )
+            @metric_streams << ms
+            metric_store.add_metric_stream(ms)
+          end
+
+          private
+
+          def update(value, attributes)
+            @metric_streams.each { |ms| ms.update(value, attributes) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module Instrument
+        # {UpDownCounter} is the SDK implementation of {OpenTelemetry::Metrics::UpDownCounter}.
+        class UpDownCounter < OpenTelemetry::SDK::Metrics::Instrument::SynchronousInstrument
+          # Returns the instrument kind as a Symbol
+          #
+          # @return [Symbol]
+          def instrument_kind
+            :up_down_counter
+          end
+
+          # Increment or decrement the UpDownCounter by a fixed amount.
+          #
+          # @param [Numeric] amount The amount to be added, can be positive, negative or zero.
+          # @param [Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}] attributes
+          #   Values must be non-nil and (array of) string, boolean or numeric type.
+          #   Array values must not contain nil elements and all elements must be of
+          #   the same basic type (string, numeric, boolean).
+          def add(amount, attributes: nil)
+            update(amount, attributes)
+            nil
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+            nil
+          end
+
+          private
+
+          def default_aggregation
+            OpenTelemetry::SDK::Metrics::Aggregation::Sum.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    # The Instrument module contains the OpenTelemetry instruments reference
+    # implementation.
+    module Instrument
+    end
+  end
+end
+
+require 'opentelemetry/sdk/metrics/instrument/synchronous_instrument'
+require 'opentelemetry/sdk/metrics/instrument/counter'
+require 'opentelemetry/sdk/metrics/instrument/histogram'
+require 'opentelemetry/sdk/metrics/instrument/observable_counter'
+require 'opentelemetry/sdk/metrics/instrument/observable_gauge'
+require 'opentelemetry/sdk/metrics/instrument/observable_up_down_counter'
+require 'opentelemetry/sdk/metrics/instrument/up_down_counter'

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    # The Metrics module contains the OpenTelemetry metrics reference
+    # implementation.
+    module Metrics
+      # {Meter} is the SDK implementation of {OpenTelemetry::Metrics::Meter}.
+      class Meter < OpenTelemetry::Metrics::Meter
+        # @api private
+        #
+        # Returns a new {Meter} instance.
+        #
+        # @param [String] name Instrumentation package name
+        # @param [String] version Instrumentation package version
+        #
+        # @return [Meter]
+        def initialize(name, version, meter_provider)
+          @mutex = Mutex.new
+          @instrument_registry = {}
+          @instrumentation_scope = InstrumentationScope.new(name, version)
+          @meter_provider = meter_provider
+        end
+
+        # @api private
+        def add_metric_reader(metric_reader)
+          @instrument_registry.each do |_n, instrument|
+            instrument.register_with_new_metric_store(metric_reader.metric_store)
+          end
+        end
+
+        def create_instrument(kind, name, unit, description, callback)
+          super do
+            case kind
+            when :counter then OpenTelemetry::SDK::Metrics::Instrument::Counter.new(name, unit, description, @instrumentation_scope, @meter_provider)
+            when :observable_counter then OpenTelemetry::SDK::Metrics::Instrument::ObservableCounter.new(name, unit, description, callback, @instrumentation_scope, @meter_provider)
+            when :histogram then OpenTelemetry::SDK::Metrics::Instrument::Histogram.new(name, unit, description, @instrumentation_scope, @meter_provider)
+            when :observable_gauge then OpenTelemetry::SDK::Metrics::Instrument::ObservableGauge.new(name, unit, description, callback, @instrumentation_scope, @meter_provider)
+            when :up_down_counter then OpenTelemetry::SDK::Metrics::Instrument::UpDownCounter.new(name, unit, description, @instrumentation_scope, @meter_provider)
+            when :observable_up_down_counter then OpenTelemetry::SDK::Metrics::Instrument::ObservableUpDownCounter.new(name, unit, description, callback, @instrumentation_scope, @meter_provider)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    # The Metrics module contains the OpenTelemetry metrics reference
+    # implementation.
+    module Metrics
+      # {MeterProvider} is the SDK implementation of {OpenTelemetry::Metrics::MeterProvider}.
+      class MeterProvider < OpenTelemetry::Metrics::MeterProvider
+        Key = Struct.new(:name, :version)
+        private_constant(:Key)
+
+        attr_reader :resource, :metric_readers
+
+        def initialize(resource: OpenTelemetry::SDK::Resources::Resource.create)
+          @mutex = Mutex.new
+          @meter_registry = {}
+          @stopped = false
+          @metric_readers = []
+          @resource = resource
+        end
+
+        # Returns a {Meter} instance.
+        #
+        # @param [String] name Instrumentation package name
+        # @param [optional String] version Instrumentation package version
+        #
+        # @return [Meter]
+        def meter(name, version: nil)
+          version ||= ''
+          if @stopped
+            OpenTelemetry.logger.warn 'calling MeterProvider#meter after shutdown, a noop meter will be returned.'
+            OpenTelemetry::Metrics::Meter.new
+          else
+            @mutex.synchronize { @meter_registry[Key.new(name, version)] ||= Meter.new(name, version, self) }
+          end
+        end
+
+        # Attempts to stop all the activity for this {MeterProvider}.
+        #
+        # Calls MetricReader#shutdown for all registered MetricReaders.
+        #
+        # After this is called all the newly created {Meter}s will be no-op.
+        #
+        # @param [optional Numeric] timeout An optional timeout in seconds.
+        # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+        #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+        def shutdown(timeout: nil)
+          @mutex.synchronize do
+            if @stopped
+              OpenTelemetry.logger.warn('calling MetricProvider#shutdown multiple times.')
+              Export::FAILURE
+            else
+              start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
+              results = @metric_readers.map do |metric_reader|
+                remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
+                if remaining_timeout&.zero?
+                  Export::TIMEOUT
+                else
+                  metric_reader.shutdown(timeout: remaining_timeout)
+                end
+              end
+
+              @stopped = true
+              results.max || Export::SUCCESS
+            end
+          end
+        end
+
+        # This method provides a way for provider to notify the registered
+        # {MetricReader} instances, so they can do as much as they could to consume
+        # or send the metrics. Note: unlike Push Metric Exporter which can send data on
+        # its own schedule, Pull Metric Exporter can only send the data when it is
+        # being asked by the scraper, so ForceFlush would not make much sense.
+        #
+        # @param [optional Numeric] timeout An optional timeout in seconds.
+        # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+        #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+        def force_flush(timeout: nil)
+          @mutex.synchronize do
+            if @stopped
+              Export::SUCCESS
+            else
+              start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
+              results = @metric_readers.map do |metric_reader|
+                remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
+                if remaining_timeout&.zero?
+                  Export::TIMEOUT
+                else
+                  metric_reader.force_flush(timeout: remaining_timeout)
+                end
+              end
+
+              results.max || Export::SUCCESS
+            end
+          end
+        end
+
+        # Adds a new MetricReader to this {MeterProvider}.
+        #
+        # @param metric_reader the new MetricReader to be added.
+        def add_metric_reader(metric_reader)
+          @mutex.synchronize do
+            if @stopped
+              OpenTelemetry.logger.warn('calling MetricProvider#add_metric_reader after shutdown.')
+            else
+              @metric_readers.push(metric_reader)
+              @meter_registry.each_value { |meter| meter.add_metric_reader(metric_reader) }
+            end
+
+            nil
+          end
+        end
+
+        # @api private
+        def register_synchronous_instrument(instrument)
+          @mutex.synchronize do
+            @metric_readers.each do |mr|
+              instrument.register_with_new_metric_store(mr.metric_store)
+            end
+          end
+        end
+
+        # The type of the Instrument(s) (optional).
+        # The name of the Instrument(s). OpenTelemetry SDK authors MAY choose to support wildcard characters, with the question mark (?) matching exactly one character and the asterisk character (*) matching zero or more characters.
+        # The name of the Meter (optional).
+        # The version of the Meter (optional).
+        # The schema_url of the Meter (optional).
+        def add_view
+          # TODO: For each meter add this view to all applicable instruments
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module State
+        # MetricData is a Struct containing {MetricStream} data for export.
+        MetricData = Struct.new(:name,                      # String
+                                :description,               # String
+                                :unit,                      # String
+                                :instrument_kind,           # Symbol
+                                :resource,                  # OpenTelemetry::SDK::Resources::Resource
+                                :instrumentation_scope,     # OpenTelemetry::SDK::InstrumentationScope
+                                :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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Metrics
+      module State
+        # @api private
+        #
+        # The MetricStore module provides SDK internal functionality that is not a part of the
+        # public API.
+        class MetricStore
+          def initialize
+            @mutex = Mutex.new
+            @epoch_start_time = now_in_nano
+            @epoch_end_time = nil
+            @metric_streams = []
+          end
+
+          def collect
+            @mutex.synchronize do
+              @epoch_end_time = now_in_nano
+              snapshot = @metric_streams.map { |ms| ms.collect(@epoch_start_time, @epoch_end_time) }
+              @epoch_start_time = @epoch_end_time
+              snapshot
+            end
+          end
+
+          def add_metric_stream(metric_stream)
+            @mutex.synchronize do
+              @metric_streams = @metric_streams.dup.push(metric_stream)
+              nil
+            end
+          end
+
+          private
+
+          def now_in_nano
+            (Time.now.to_r * 1_000_000_000).to_i
+          end
+        end
+      end
+    end
+  end
+end