opentelemetry-sdk 0.14.0 → 1.0.0.rc2

data/lib/opentelemetry/sdk/baggage.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-require 'opentelemetry/sdk/baggage/builder'
-require 'opentelemetry/sdk/baggage/manager'
-
-module OpenTelemetry
-  module SDK
-    # Contains operational implementations of the Baggage::Manager
-    module Baggage
-    end
-  end
-end

data/lib/opentelemetry/sdk/baggage/builder.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Baggage
-      # SDK implementation of Baggage::Builder
-      class Builder
-        attr_reader :entries
-
-        def initialize(entries)
-          @entries = entries
-        end
-
-        # Set key-value in the to-be-created baggage
-        #
-        # @param [String] key The key to store this value under
-        # @param [String] value String value to be stored under key
-        def set_value(key, value)
-          @entries[key] = value.to_s
-        end
-
-        # Removes key from the to-be-created baggage
-        #
-        # @param [String] key The key to remove
-        def remove_value(key)
-          @entries.delete(key)
-        end
-
-        # Clears all baggage from the to-be-created baggage
-        def clear
-          @entries.clear
-        end
-      end
-    end
-  end
-end

data/lib/opentelemetry/sdk/baggage/manager.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Baggage
-      # Manages baggage
-      class Manager
-        BAGGAGE_KEY = OpenTelemetry::Baggage::Propagation::ContextKeys.baggage_key
-        EMPTY_BAGGAGE = {}.freeze
-        private_constant(:BAGGAGE_KEY, :EMPTY_BAGGAGE)
-
-        # Used to chain modifications to baggage. The result is a
-        # context with an updated baggage. If only a single
-        # modification is being made to baggage, use the other
-        # methods on +Manager+, if multiple modifications are being made, use
-        # this one.
-        #
-        # @param [optional Context] context The context to update with with new
-        #   modified baggage. Defaults to +Context.current+
-        # @return [Context]
-        def build_context(context: Context.current)
-          builder = Builder.new(baggage_for(context).dup)
-          yield builder
-          context.set_value(BAGGAGE_KEY, builder.entries)
-        end
-
-        # Returns a new context with empty baggage
-        #
-        # @param [optional Context] context Context to clear baggage from. Defaults
-        #   to +Context.current+
-        # @return [Context]
-        def clear(context: Context.current)
-          context.set_value(BAGGAGE_KEY, EMPTY_BAGGAGE)
-        end
-
-        # Returns the corresponding baggage value (or nil) for key
-        #
-        # @param [String] key The lookup key
-        # @param [optional Context] context The context from which to retrieve
-        #   the key.
-        #   Defaults to +Context.current+
-        # @return [String]
-        def value(key, context: Context.current)
-          baggage_for(context)[key]
-        end
-
-        # Returns the baggage
-        #
-        # @param [optional Context] context The context from which to retrieve
-        #   the baggage.
-        #   Defaults to +Context.current+
-        # @return [Hash]
-        def values(context: Context.current)
-          baggage_for(context).dup.freeze
-        end
-
-        # Returns a new context with new key-value pair
-        #
-        # @param [String] key The key to store this value under
-        # @param [String] value String value to be stored under key
-        # @param [optional Context] context The context to update with new
-        #   value. Defaults to +Context.current+
-        # @return [Context]
-        def set_value(key, value, context: Context.current)
-          new_baggage = baggage_for(context).dup
-          new_baggage[key] = value
-          context.set_value(BAGGAGE_KEY, new_baggage)
-        end
-
-        # Returns a new context with value at key removed
-        #
-        # @param [String] key The key to remove
-        # @param [optional Context] context The context to remove baggage
-        #   from. Defaults to +Context.current+
-        # @return [Context]
-        def remove_value(key, context: Context.current)
-          baggage = baggage_for(context)
-          return context unless baggage.key?(key)
-
-          new_baggage = baggage.dup
-          new_baggage.delete(key)
-          context.set_value(BAGGAGE_KEY, new_baggage)
-        end
-
-        private
-
-        def baggage_for(context)
-          context.value(BAGGAGE_KEY) || EMPTY_BAGGAGE
-        end
-      end
-    end
-  end
-end

data/lib/opentelemetry/sdk/trace/config.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Trace
-      # The Config module contains the configuration logic for the
-      # OpenTelemetry SDK.
-      module Config
-      end
-    end
-  end
-end
-
-require 'opentelemetry/sdk/trace/config/trace_config'

data/lib/opentelemetry/sdk/trace/config/trace_config.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Trace
-      module Config
-        # Class that holds global trace parameters.
-        class TraceConfig
-          # The global default sampler (see {Samplers}).
-          attr_reader :sampler
-
-          # The global default max number of attributes per {Span}.
-          attr_reader :max_attributes_count
-
-          # The global default max number of {OpenTelemetry::SDK::Trace::Event}s per {Span}.
-          attr_reader :max_events_count
-
-          # The global default max number of {OpenTelemetry::Trace::Link} entries per {Span}.
-          attr_reader :max_links_count
-
-          # The global default max number of attributes per {OpenTelemetry::SDK::Trace::Event}.
-          attr_reader :max_attributes_per_event
-
-          # The global default max number of attributes per {OpenTelemetry::Trace::Link}.
-          attr_reader :max_attributes_per_link
-
-          # Returns a {TraceConfig} with the desired values.
-          #
-          # @return [TraceConfig] with the desired values.
-          # @raise [ArgumentError] if any of the max numbers are not positive.
-          def initialize(sampler: sampler_from_environment(Samplers.parent_based(root: Samplers::ALWAYS_ON)),
-                         max_attributes_count: Integer(ENV.fetch('OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT', 1000)),
-                         max_events_count: Integer(ENV.fetch('OTEL_SPAN_EVENT_COUNT_LIMIT', 1000)),
-                         max_links_count: Integer(ENV.fetch('OTEL_SPAN_LINK_COUNT_LIMIT', 1000)),
-                         max_attributes_per_event: max_attributes_count,
-                         max_attributes_per_link: max_attributes_count)
-            raise ArgumentError, 'max_attributes_count must be positive' unless max_attributes_count.positive?
-            raise ArgumentError, 'max_events_count must be positive' unless max_events_count.positive?
-            raise ArgumentError, 'max_links_count must be positive' unless max_links_count.positive?
-            raise ArgumentError, 'max_attributes_per_event must be positive' unless max_attributes_per_event.positive?
-            raise ArgumentError, 'max_attributes_per_link must be positive' unless max_attributes_per_link.positive?
-
-            @sampler = sampler
-            @max_attributes_count = max_attributes_count
-            @max_events_count = max_events_count
-            @max_links_count = max_links_count
-            @max_attributes_per_event = max_attributes_per_event
-            @max_attributes_per_link = max_attributes_per_link
-          end
-
-          # TODO: from_proto
-          private
-
-          def sampler_from_environment(default_sampler) # rubocop:disable Metrics/CyclomaticComplexity
-            case ENV['OTEL_TRACE_SAMPLER']
-            when 'always_on' then Samplers::ALWAYS_ON
-            when 'always_off' then Samplers::ALWAYS_OFF
-            when 'traceidratio' then Samplers.trace_id_ratio_based(Float(ENV.fetch('OTEL_TRACE_SAMPLER_ARG', 1.0)))
-            when 'parentbased_always_on' then Samplers.parent_based(root: Samplers::ALWAYS_ON)
-            when 'parentbased_always_off' then Samplers.parent_based(root: Samplers::ALWAYS_OFF)
-            when 'parentbased_traceidratio' then Samplers.parent_based(root: Samplers.trace_id_ratio_based(Float(ENV.fetch('OTEL_TRACE_SAMPLER_ARG', 1.0))))
-            else default_sampler
-            end
-          rescue StandardError => e
-            OpenTelemetry.handle_error(exception: e, message: "installing default sampler #{default_sampler.description}")
-            default_sampler
-          end
-
-          # The default {TraceConfig}.
-          DEFAULT = new
-        end
-      end
-    end
-  end
-end

data/lib/opentelemetry/sdk/trace/export/multi_span_exporter.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Trace
-      module Export
-        # Implementation of the SpanExporter duck type that simply forwards all
-        # received spans to a collection of SpanExporters.
-        #
-        # Can be used to export to multiple backends using the same
-        # SpanProcessor like a {SimpleSpanProcessor} or a
-        # {BatchSpanProcessor}.
-        class MultiSpanExporter
-          def initialize(span_exporters)
-            @span_exporters = span_exporters.clone.freeze
-          end
-
-          # Called to export sampled {Span}s.
-          #
-          # @param [Enumerable<Span>] spans the list of sampled {Span}s to be
-          #   exported.
-          # @param [optional Numeric] timeout An optional timeout in seconds.
-          # @return [Integer] the result of the export.
-          def export(spans, timeout: nil)
-            start_time = Time.now
-            results = @span_exporters.map do |span_exporter|
-              span_exporter.export(spans, timeout: OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
-            rescue => e # rubocop:disable Style/RescueStandardError
-              OpenTelemetry.logger.warn("exception raised by export - #{e}")
-              FAILURE
-            end
-            results.uniq.max || SUCCESS
-          end
-
-          # Called when {TracerProvider#shutdown} is called, if this exporter is
-          # registered to a {TracerProvider} object.
-          #
-          # @param [optional Numeric] timeout An optional timeout in seconds.
-          # @return [Integer] SUCCESS if no error occurred, FAILURE if a
-          #   non-specific failure occurred, TIMEOUT if a timeout occurred.
-          def shutdown(timeout: nil)
-            start_time = Time.now
-            results = @span_exporters.map do |processor|
-              remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
-              return TIMEOUT if remaining_timeout&.zero?
-
-              processor.shutdown(timeout: remaining_timeout)
-            end
-            results.uniq.max || SUCCESS
-          end
-        end
-      end
-    end
-  end
-end

data/lib/opentelemetry/sdk/trace/multi_span_processor.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Trace
-      # Implementation of the SpanProcessor duck type that simply forwards all
-      # received events to a list of SpanProcessors.
-      class MultiSpanProcessor
-        # Creates a new {MultiSpanProcessor}.
-        #
-        # @param [Enumerable<SpanProcessor>] span_processors a collection of
-        #   SpanProcessors.
-        # @return [MultiSpanProcessor]
-        def initialize(span_processors)
-          @span_processors = span_processors.to_a.freeze
-        end
-
-        # Called when a {Span} is started, if the {Span#recording?}
-        # returns true.
-        #
-        # This method is called synchronously on the execution thread, should
-        # not throw or block the execution thread.
-        #
-        # @param [Span] span the {Span} that just started.
-        # @param [Context] parent_context the parent {Context} of the newly
-        #  started span.
-        def on_start(span, parent_context)
-          @span_processors.each { |processor| processor.on_start(span, parent_context) }
-        end
-
-        # Called when a {Span} is ended, if the {Span#recording?}
-        # returns true.
-        #
-        # This method is called synchronously on the execution thread, should
-        # not throw or block the execution thread.
-        #
-        # @param [Span] span the {Span} that just ended.
-        def on_finish(span)
-          @span_processors.each { |processor| processor.on_finish(span) }
-        end
-
-        # Export all ended spans 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 `Processor` exports
-        # the completed spans.
-        #
-        # @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)
-          start_time = Time.now
-          results = @span_processors.map do |processor|
-            remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
-            return Export::TIMEOUT if remaining_timeout&.zero?
-
-            processor.force_flush(timeout: remaining_timeout)
-          end
-          results.uniq.max
-        end
-
-        # Called when {TracerProvider#shutdown} is called.
-        #
-        # @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)
-          start_time = Time.now
-          results = @span_processors.map do |processor|
-            remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
-            return Export::TIMEOUT if remaining_timeout&.zero?
-
-            processor.shutdown(timeout: remaining_timeout)
-          end
-          results.uniq.max
-        end
-      end
-    end
-  end
-end