opentelemetry-sdk 1.0.0.rc1 → 1.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5e0b06b7a072f462eeef975e4342a9e9800fb85794e2625f454d17eb20ef2be
-  data.tar.gz: a42a11084a981f147bdc5a3c5d21f1a4a1752d5a971819658573cb4964d43f49
+  metadata.gz: d43559eaa2be64a3597d078d032c168429702e47bdeaee1ac454dc5e74f9f496
+  data.tar.gz: 583f42bb1b6543d6375d3cfc8e4bd2319d5146306f42a73d726ca73f3c01e56d
 SHA512:
-  metadata.gz: 670059ca8ef7d7aeba579c6b70a8217ac5e4fa879b39afee715b4ff1852e8643bf87581943b70d949480a728c531d20efc8ed42fa878f0a5291d55f31cc22607
-  data.tar.gz: 604feaa8d9952cce4a0eff45b743601b85ea2a5f7b03af316c5ae45c6df2fd57a2712d43d417a30a2df44b493fd6c8bc03f8924014a75d2fd29b9bfe513c7adf
+  metadata.gz: 14112a30284f0ececabcf75dda91f6634b3748c44ccec52e19c6d42e7fae59979e6ea82ef276d21ea5503d2b4f35821945b62d2b1afc83c5bcb9d4a6a9ce6bf4
+  data.tar.gz: 87aaa08db88b9495c86ee1135cdcbfb95827fbbed42edf3280500d86025ff269ee3af95c675e20231267e7b561082cea12df7738db004922468246ad437805fb

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Release History: opentelemetry-sdk
 
+### v1.0.0.rc2 / 2021-06-23
+
+* BREAKING CHANGE: Remove optional parent_context from in_span [729](https://github.com/open-telemetry/opentelemetry-ruby/pull/729)
+* BREAKING CHANGE: Replace Time.now with Process.clock_gettime [717](https://github.com/open-telemetry/opentelemetry-ruby/pull/717)
+* BREAKING CHANGE: Refactor Baggage to remove Noop* [800](https://github.com/open-telemetry/opentelemetry-ruby/pull/800)
+* BREAKING CHANGE: Remove unnecessary readers from SDK Tracer [820](https://github.com/open-telemetry/opentelemetry-ruby/pull/820)
+  - Tracer no longer surfaces attribute readers for the name, version, or tracer_provider
+* BREAKING CHANGE: Total order constraint on span.status= [805](https://github.com/open-telemetry/opentelemetry-ruby/pull/805)
+
+* ADDED: Add Tracer.non_recording_span to API [799](https://github.com/open-telemetry/opentelemetry-ruby/pull/799)
+* ADDED: Add unnamed tracer warning message [830](https://github.com/open-telemetry/opentelemetry-ruby/pull/830)
+* ADDED: Allow disabling of install messages [831](https://github.com/open-telemetry/opentelemetry-ruby/pull/831)
+* FIXED: Rename cloud.zone to cloud.availability_zone [734](https://github.com/open-telemetry/opentelemetry-ruby/pull/734)
+* FIXED: Improve attribute error messages [742](https://github.com/open-telemetry/opentelemetry-ruby/pull/742)
+* FIXED: Support OTEL_SERVICE_NAME env var [806]https://github.com/open-telemetry/opentelemetry-ruby/pull/806
+* FIXED: Flakey tracer provider test
+
 ### v1.0.0.rc1 / 2021-05-21
 
 * BREAKING CHANGE: Remove optional parent_context from in_span

data/lib/opentelemetry/sdk.rb

@@ -55,7 +55,7 @@ module OpenTelemetry
     #   Configure everything
     #
     #     OpenTelemetry::SDK.configure do |c|
-    #       c.logger = Logger.new('/dev/null')
+    #       c.logger = Logger.new(File::NULL)
     #       c.add_span_processor SpanProcessor.new(SomeExporter.new)
     #       c.use_all
     #     end
@@ -74,6 +74,7 @@ module OpenTelemetry
 end
 
 require 'opentelemetry/sdk/configurator'
+require 'opentelemetry/sdk/forwarding_logger'
 require 'opentelemetry/sdk/internal'
 require 'opentelemetry/sdk/instrumentation_library'
 require 'opentelemetry/sdk/resources'

data/lib/opentelemetry/sdk/configurator.rb

@@ -15,7 +15,7 @@ module OpenTelemetry
 
       private_constant :USE_MODE_UNSPECIFIED, :USE_MODE_ONE, :USE_MODE_ALL
 
-      attr_writer :logger, :propagators, :error_handler, :id_generator
+      attr_writer :propagators, :error_handler, :id_generator
 
       def initialize
         @instrumentation_names = []
@@ -31,6 +31,15 @@ module OpenTelemetry
         @logger ||= OpenTelemetry.logger
       end
 
+      # Accepts a logger and wraps it in the {ForwardingLogger} which allows
+      # for controlling the severity level emitted by the OpenTelemetry.logger
+      # independently of the supplied logger.
+      #
+      # @param [Logger] new_logger The logger for OpenTelemetry to use
+      def logger=(new_logger)
+        @logger = ForwardingLogger.new(new_logger, level: ENV['OTEL_LOG_LEVEL'] || Logger::INFO)
+      end
+
       def error_handler
         @error_handler ||= OpenTelemetry.error_handler
       end
@@ -112,7 +121,6 @@ module OpenTelemetry
       def configure
         OpenTelemetry.logger = logger
         OpenTelemetry.error_handler = error_handler
-        OpenTelemetry.baggage = Baggage::Manager.new
         configure_propagation
         configure_span_processors
         tracer_provider.id_generator = @id_generator
@@ -123,7 +131,7 @@ module OpenTelemetry
       private
 
       def tracer_provider
-        @tracer_provider ||= Trace::TracerProvider.new(@resource)
+        @tracer_provider ||= Trace::TracerProvider.new(resource: @resource)
       end
 
       def check_use_mode!(mode)

data/lib/opentelemetry/sdk/forwarding_logger.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module OpenTelemetry
+  module SDK
+    # The ForwardingLogger provides a wrapper to control the OpenTelemetry
+    # log level, while respecting the configured level of the supplied logger.
+    # If the OTEL_LOG_LEVEL is set to debug, and the supplied logger is configured
+    # with an ERROR log level, only OpenTelemetry logs at the ERROR level or higher
+    # will be emitted.
+    class ForwardingLogger
+      def initialize(logger, level:) # rubocop:disable Metrics/CyclomaticComplexity
+        @logger = logger
+
+        if level.is_a?(Integer)
+          @level = level
+        else
+          case level.to_s.downcase
+          when 'debug'
+            @level = Logger::DEBUG
+          when 'info'
+            @level = Logger::INFO
+          when 'warn'
+            @level = Logger::WARN
+          when 'error'
+            @level = Logger::ERROR
+          when 'fatal'
+            @level = Logger::FATAL
+          when 'unknown'
+            @level = Logger::UNKNOWN
+          else
+            raise ArgumentError, "invalid log level: #{level}"
+          end
+        end
+      end
+
+      def add(severity, message = nil, progname = nil)
+        return true if severity < @level
+
+        @logger.add(severity, message, progname)
+      end
+
+      def debug(progname = nil, &block)
+        add(Logger::DEBUG, nil, progname, &block)
+      end
+
+      def info(progname = nil, &block)
+        add(Logger::INFO, nil, progname, &block)
+      end
+
+      def warn(progname = nil, &block)
+        add(Logger::WARN, nil, progname, &block)
+      end
+
+      def error(progname = nil, &block)
+        add(Logger::ERROR, nil, progname, &block)
+      end
+
+      def fatal(progname = nil, &block)
+        add(Logger::FATAL, nil, progname, &block)
+      end
+
+      def unknown(progname = nil, &block)
+        add(Logger::UNKNOWN, nil, progname, &block)
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/resources/resource.rb

@@ -31,7 +31,7 @@ module OpenTelemetry
           end
 
           def default
-            @default ||= create(Constants::SERVICE_RESOURCE[:name] => 'unknown_service').merge(process).merge(telemetry_sdk)
+            @default ||= create(Constants::SERVICE_RESOURCE[:name] => 'unknown_service').merge(process).merge(telemetry_sdk).merge(service_name_from_env)
           end
 
           def telemetry_sdk
@@ -64,6 +64,13 @@ module OpenTelemetry
 
             create(resource_attributes)
           end
+
+          private
+
+          def service_name_from_env
+            service_name = ENV['OTEL_SERVICE_NAME']
+            create(Constants::SERVICE_RESOURCE[:name] => service_name) unless service_name.nil?
+          end
         end
 
         # @api private

data/lib/opentelemetry/sdk/trace.rb

@@ -14,12 +14,11 @@ module OpenTelemetry
 end
 
 require 'opentelemetry/sdk/trace/samplers'
-require 'opentelemetry/sdk/trace/config'
+require 'opentelemetry/sdk/trace/span_limits'
 require 'opentelemetry/sdk/trace/event'
 require 'opentelemetry/sdk/trace/export'
-require 'opentelemetry/sdk/trace/multi_span_processor'
-require 'opentelemetry/sdk/trace/noop_span_processor'
 require 'opentelemetry/sdk/trace/span_data'
+require 'opentelemetry/sdk/trace/span_processor'
 require 'opentelemetry/sdk/trace/span'
 require 'opentelemetry/sdk/trace/tracer'
 require 'opentelemetry/sdk/trace/tracer_provider'

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

@@ -31,6 +31,5 @@ require 'opentelemetry/sdk/trace/export/batch_span_processor'
 require 'opentelemetry/sdk/trace/export/console_span_exporter'
 require 'opentelemetry/sdk/trace/export/in_memory_span_exporter'
 require 'opentelemetry/sdk/trace/export/metrics_reporter'
-require 'opentelemetry/sdk/trace/export/multi_span_exporter'
-require 'opentelemetry/sdk/trace/export/noop_span_exporter'
+require 'opentelemetry/sdk/trace/export/span_exporter'
 require 'opentelemetry/sdk/trace/export/simple_span_processor'

data/lib/opentelemetry/sdk/trace/export/{noop_span_exporter.rb → span_exporter.rb}

@@ -8,24 +8,25 @@ module OpenTelemetry
   module SDK
     module Trace
       module Export
-        # A noop exporter that demonstrates and documents the SpanExporter
-        # duck type. SpanExporter allows different tracing services to export
+        # SpanExporter describes a duck type. It is not required to subclass this
+        # class to provide an implementation of SpanExporter, provided the interface is
+        # satisfied. SpanExporter allows different tracing services to export
         # recorded data for sampled spans in their own format.
         #
         # To export data an exporter MUST be registered to the {TracerProvider} using
-        # a {SimpleSpanProcessor} or a {BatchSpanProcessor}.
-        class NoopSpanExporter
+        # a {SpanProcessor} implementation.
+        class SpanExporter
           def initialize
             @stopped = false
           end
 
-          # Called to export sampled {Span}s.
+          # Called to export sampled {SpanData}s.
           #
-          # @param [Enumerable<Span>] spans the list of sampled {Span}s to be
+          # @param [Enumerable<SpanData>] span_data the list of sampled {SpanData} to be
           #   exported.
           # @param [optional Numeric] timeout An optional timeout in seconds.
           # @return [Integer] the result of the export.
-          def export(spans, timeout: nil)
+          def export(span_data, timeout: nil)
             return SUCCESS unless @stopped
 
             FAILURE

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

@@ -10,13 +10,13 @@ module OpenTelemetry
       # Implementation of {OpenTelemetry::Trace::Span} that records trace events.
       #
       # This implementation includes reader methods intended to allow access to
-      # internal state by SpanProcessors (see {NoopSpanProcessor} for the interface).
+      # internal state by {SpanProcessor}s.
       # Instrumentation should use the API provided by {OpenTelemetry::Trace::Span}
       # and should consider {Span} to be write-only.
       #
       # rubocop:disable Metrics/ClassLength
       class Span < OpenTelemetry::Trace::Span
-        DEFAULT_STATUS = OpenTelemetry::Trace::Status.new(OpenTelemetry::Trace::Status::UNSET)
+        DEFAULT_STATUS = OpenTelemetry::Trace::Status.unset
         EMPTY_ATTRIBUTES = {}.freeze
 
         private_constant :DEFAULT_STATUS, :EMPTY_ATTRIBUTES
@@ -159,7 +159,7 @@ module OpenTelemetry
           event_attributes = {
             'exception.type' => exception.class.to_s,
             'exception.message' => exception.message,
-            'exception.stacktrace' => exception.full_message(highlight: false, order: :top)
+            'exception.stacktrace' => exception.full_message(highlight: false, order: :top).encode('UTF-8', invalid: :replace, undef: :replace, replace: '�')
           }
           event_attributes.merge!(attributes) unless attributes.nil?
           add_event('exception', attributes: event_attributes)
@@ -167,20 +167,23 @@ module OpenTelemetry
 
         # Sets the Status to the Span
         #
-        # If used, this will override the default Span status. Default is OK.
+        # If used, this will override the default Span status. Default has code = Status::UNSET.
         #
-        # Only the value of the last call will be recorded, and implementations
-        # are free to ignore previous calls.
+        # An attempt to set the status with code == Status::UNSET is ignored.
+        # If the status is set with code == Status::OK, any further attempt to set the status
+        # is ignored.
         #
         # @param [Status] status The new status, which overrides the default Span
-        #   status, which is OK.
+        #   status, which has code = Status::UNSET.
         #
         # @return [void]
         def status=(status)
+          return if status.code == OpenTelemetry::Trace::Status::UNSET
+
           @mutex.synchronize do
             if @ended
               OpenTelemetry.logger.warn('Calling status= on an ended Span.')
-            else
+            elsif @status.code != OpenTelemetry::Trace::Status::OK
               @status = status
             end
           end
@@ -235,7 +238,7 @@ module OpenTelemetry
             @events.freeze
             @ended = true
           end
-          @span_processor.on_finish(self)
+          @span_processors.each { |processor| processor.on_finish(self) }
           self
         end
 
@@ -273,14 +276,14 @@ module OpenTelemetry
         end
 
         # @api private
-        def initialize(context, parent_context, name, kind, parent_span_id, trace_config, span_processor, attributes, links, start_timestamp, resource, instrumentation_library) # rubocop:disable Metrics/AbcSize
+        def initialize(context, parent_context, name, kind, parent_span_id, span_limits, span_processors, attributes, links, start_timestamp, resource, instrumentation_library) # rubocop:disable Metrics/AbcSize
           super(span_context: context)
           @mutex = Mutex.new
           @name = name
           @kind = kind
           @parent_span_id = parent_span_id.freeze || OpenTelemetry::Trace::INVALID_SPAN_ID
-          @trace_config = trace_config
-          @span_processor = span_processor
+          @span_limits = span_limits
+          @span_processors = span_processors
           @resource = resource
           @instrumentation_library = instrumentation_library
           @ended = false
@@ -293,8 +296,8 @@ module OpenTelemetry
           @attributes = attributes.nil? ? nil : Hash[attributes] # We need a mutable copy of attributes.
           trim_span_attributes(@attributes)
           @events = nil
-          @links = trim_links(links, trace_config.max_links_count, trace_config.max_attributes_per_link)
-          @span_processor.on_start(self, parent_context)
+          @links = trim_links(links, span_limits.link_count_limit, span_limits.attribute_per_link_count_limit)
+          @span_processors.each { |processor| processor.on_start(self, parent_context) }
         end
 
         # TODO: Java implementation overrides finalize to log if a span isn't finished.
@@ -310,7 +313,7 @@ module OpenTelemetry
         def trim_span_attributes(attrs)
           return if attrs.nil?
 
-          excess = attrs.size - @trace_config.max_attributes_count
+          excess = attrs.size - @span_limits.attribute_count_limit
           excess.times { attrs.shift } if excess.positive?
           truncate_attribute_values(attrs)
           nil
@@ -319,51 +322,51 @@ module OpenTelemetry
         def truncate_attribute_values(attrs)
           return EMPTY_ATTRIBUTES if attrs.nil?
 
-          max_attributes_length = @trace_config.max_attributes_length
-          attrs.each { |key, value| attrs[key] = OpenTelemetry::Common::Utilities.truncate(value, max_attributes_length) } if max_attributes_length
+          attribute_length_limit = @span_limits.attribute_length_limit
+          attrs.each { |key, value| attrs[key] = OpenTelemetry::Common::Utilities.truncate(value, attribute_length_limit) } if attribute_length_limit
           attrs
         end
 
-        def trim_links(links, max_links_count, max_attributes_per_link) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def trim_links(links, link_count_limit, attribute_per_link_count_limit) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           # Fast path (likely) common cases.
           return nil if links.nil?
 
-          if links.size <= max_links_count &&
-             links.all? { |link| link.attributes.size <= max_attributes_per_link && Internal.valid_attributes?(name, 'link', link.attributes) }
+          if links.size <= link_count_limit &&
+             links.all? { |link| link.attributes.size <= attribute_per_link_count_limit && Internal.valid_attributes?(name, 'link', link.attributes) }
             return links.frozen? ? links : links.clone.freeze
           end
 
           # Slow path: trim attributes for each Link.
-          links.last(max_links_count).map! do |link|
+          links.last(link_count_limit).map! do |link|
             attrs = Hash[link.attributes] # link.attributes is frozen, so we need an unfrozen copy to adjust.
             attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
-            excess = attrs.size - max_attributes_per_link
+            excess = attrs.size - attribute_per_link_count_limit
             excess.times { attrs.shift } if excess.positive?
             OpenTelemetry::Trace::Link.new(link.span_context, attrs)
           end.freeze
         end
 
         def append_event(events, event) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          max_events_count = @trace_config.max_events_count
-          max_attributes_per_event = @trace_config.max_attributes_per_event
+          event_count_limit = @span_limits.event_count_limit
+          attribute_per_event_count_limit = @span_limits.attribute_per_event_count_limit
           valid_attributes = Internal.valid_attributes?(name, 'event', event.attributes)
 
           # Fast path (likely) common case.
-          if events.size < max_events_count &&
-             event.attributes.size <= max_attributes_per_event &&
+          if events.size < event_count_limit &&
+             event.attributes.size <= attribute_per_event_count_limit &&
              valid_attributes
             return events << event
           end
 
           # Slow path.
-          excess = events.size + 1 - max_events_count
+          excess = events.size + 1 - event_count_limit
           events.shift(excess) if excess.positive?
 
-          excess = event.attributes.size - max_attributes_per_event
+          excess = event.attributes.size - attribute_per_event_count_limit
           if excess.positive? || !valid_attributes
             attrs = Hash[event.attributes] # event.attributes is frozen, so we need an unfrozen copy to adjust.
             attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
-            excess = attrs.size - max_attributes_per_event
+            excess = attrs.size - attribute_per_event_count_limit
             excess.times { attrs.shift } if excess.positive?
             event = Event.new(event.name, attrs.freeze, event.timestamp)
           end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      # Class that holds global trace parameters.
+      class SpanLimits
+        # The global default max number of attributes per {Span}.
+        attr_reader :attribute_count_limit
+
+        # The global default max length of attribute value per {Span}.
+        attr_reader :attribute_length_limit
+
+        # The global default max number of {OpenTelemetry::SDK::Trace::Event}s per {Span}.
+        attr_reader :event_count_limit
+
+        # The global default max number of {OpenTelemetry::Trace::Link} entries per {Span}.
+        attr_reader :link_count_limit
+
+        # The global default max number of attributes per {OpenTelemetry::SDK::Trace::Event}.
+        attr_reader :attribute_per_event_count_limit
+
+        # The global default max number of attributes per {OpenTelemetry::Trace::Link}.
+        attr_reader :attribute_per_link_count_limit
+
+        # Returns a {SpanLimits} with the desired values.
+        #
+        # @return [SpanLimits] with the desired values.
+        # @raise [ArgumentError] if any of the max numbers are not positive.
+        def initialize(attribute_count_limit: Integer(ENV.fetch('OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT', 128)), # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+                       attribute_length_limit: ENV['OTEL_RUBY_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT'],
+                       event_count_limit: Integer(ENV.fetch('OTEL_SPAN_EVENT_COUNT_LIMIT', 128)),
+                       link_count_limit: Integer(ENV.fetch('OTEL_SPAN_LINK_COUNT_LIMIT', 128)),
+                       attribute_per_event_count_limit: attribute_count_limit,
+                       attribute_per_link_count_limit: attribute_count_limit)
+          raise ArgumentError, 'attribute_count_limit must be positive' unless attribute_count_limit.positive?
+          raise ArgumentError, 'attribute_length_limit must not be less than 32' unless attribute_length_limit.nil? || Integer(attribute_length_limit) >= 32
+          raise ArgumentError, 'event_count_limit must be positive' unless event_count_limit.positive?
+          raise ArgumentError, 'link_count_limit must be positive' unless link_count_limit.positive?
+          raise ArgumentError, 'attribute_per_event_count_limit must be positive' unless attribute_per_event_count_limit.positive?
+          raise ArgumentError, 'attribute_per_link_count_limit must be positive' unless attribute_per_link_count_limit.positive?
+
+          @attribute_count_limit = attribute_count_limit
+          @attribute_length_limit = attribute_length_limit.nil? ? nil : Integer(attribute_length_limit)
+          @event_count_limit = event_count_limit
+          @link_count_limit = link_count_limit
+          @attribute_per_event_count_limit = attribute_per_event_count_limit
+          @attribute_per_link_count_limit = attribute_per_link_count_limit
+        end
+
+        # The default {SpanLimits}.
+        DEFAULT = new
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/trace/{noop_span_processor.rb → span_processor.rb}

@@ -4,17 +4,14 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-require 'singleton'
-
 module OpenTelemetry
   module SDK
     module Trace
-      # NoopSpanProcessor is a singleton implementation of the duck type
-      # SpanProcessor that provides synchronous no-op hooks for when a
-      # {Span} is started or when a {Span} is ended.
-      class NoopSpanProcessor
-        include Singleton
-
+      # SpanProcessor describes a duck type and provides synchronous no-op hooks for when a
+      # {Span} is started or when a {Span} is ended. It is not required to subclass this
+      # class to provide an implementation of SpanProcessor, provided the interface is
+      # satisfied.
+      class SpanProcessor
         # Called when a {Span} is started, if the {Span#recording?}
         # returns true.
         #

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

@@ -9,10 +9,6 @@ module OpenTelemetry
     module Trace
       # {Tracer} is the SDK implementation of {OpenTelemetry::Trace::Tracer}.
       class Tracer < OpenTelemetry::Trace::Tracer
-        attr_reader :name
-        attr_reader :version
-        attr_reader :tracer_provider
-
         # @api private
         #
         # Returns a new {Tracer} instance.
@@ -23,8 +19,6 @@ module OpenTelemetry
         #
         # @return [Tracer]
         def initialize(name, version, tracer_provider)
-          @name = name
-          @version = version
           @instrumentation_library = InstrumentationLibrary.new(name, version)
           @tracer_provider = tracer_provider
         end
@@ -42,37 +36,7 @@ module OpenTelemetry
             parent_span_id = parent_span_context.span_id
             trace_id = parent_span_context.trace_id
           end
-          trace_id ||= tracer_provider.id_generator.generate_trace_id
-          sampler = tracer_provider.active_trace_config.sampler
-          result = sampler.should_sample?(trace_id: trace_id, parent_context: with_parent, links: links, name: name, kind: kind, attributes: attributes)
-          internal_create_span(result, name, kind, trace_id, parent_span_id, attributes, links, start_timestamp, with_parent)
-        end
-
-        private
-
-        def internal_create_span(result, name, kind, trace_id, parent_span_id, attributes, links, start_timestamp, parent_context) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-          span_id = tracer_provider.id_generator.generate_span_id
-          if result.recording? && !tracer_provider.stopped?
-            trace_flags = result.sampled? ? OpenTelemetry::Trace::TraceFlags::SAMPLED : OpenTelemetry::Trace::TraceFlags::DEFAULT
-            context = OpenTelemetry::Trace::SpanContext.new(trace_id: trace_id, span_id: span_id, trace_flags: trace_flags, tracestate: result.tracestate)
-            attributes = attributes&.merge(result.attributes) || result.attributes
-            Span.new(
-              context,
-              parent_context,
-              name,
-              kind,
-              parent_span_id,
-              tracer_provider.active_trace_config,
-              tracer_provider.active_span_processor,
-              attributes,
-              links,
-              start_timestamp,
-              tracer_provider.resource,
-              @instrumentation_library
-            )
-          else
-            OpenTelemetry::Trace::Span.new(span_context: OpenTelemetry::Trace::SpanContext.new(trace_id: trace_id, span_id: span_id, tracestate: result.tracestate))
-          end
+          @tracer_provider.internal_create_span(name, kind, trace_id, parent_span_id, attributes, links, start_timestamp, with_parent, @instrumentation_library)
         end
       end
     end

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

@@ -8,24 +8,35 @@ module OpenTelemetry
   module SDK
     module Trace
       # {TracerProvider} is the SDK implementation of {OpenTelemetry::Trace::TracerProvider}.
-      class TracerProvider < OpenTelemetry::Trace::TracerProvider
+      class TracerProvider < OpenTelemetry::Trace::TracerProvider # rubocop:disable Metrics/ClassLength
         Key = Struct.new(:name, :version)
         private_constant(:Key)
 
-        attr_accessor :active_trace_config, :id_generator
-        attr_reader :active_span_processor, :stopped, :resource
-        alias stopped? stopped
+        attr_accessor :span_limits, :id_generator, :sampler
+        attr_reader :resource
 
         # Returns a new {TracerProvider} instance.
         #
+        # @param [optional Sampler] sampler The sampling policy for new spans
+        # @param [optional Resource] resource The resource to associate with spans
+        #   created by Tracers created by this TracerProvider
+        # @param [optional IDGenerator] id_generator The trace and span ID generation
+        #   policy
+        # @param [optional SpanLimits] span_limits The limits to apply to attribute,
+        #   event and link counts for Spans created by Tracers created by this
+        #   TracerProvider
+        #
         # @return [TracerProvider]
-        def initialize(resource = OpenTelemetry::SDK::Resources::Resource.create)
+        def initialize(sampler: sampler_from_environment(Samplers.parent_based(root: Samplers::ALWAYS_ON)),
+                       resource: OpenTelemetry::SDK::Resources::Resource.create,
+                       id_generator: OpenTelemetry::Trace,
+                       span_limits: SpanLimits::DEFAULT)
           @mutex = Mutex.new
           @registry = {}
-          @active_span_processor = NoopSpanProcessor.instance
-          @active_trace_config = Config::TraceConfig::DEFAULT
-          @id_generator = OpenTelemetry::Trace
-          @registered_span_processors = []
+          @span_processors = []
+          @span_limits = span_limits
+          @sampler = sampler
+          @id_generator = id_generator
           @stopped = false
           @resource = resource
         end
@@ -39,6 +50,7 @@ module OpenTelemetry
         def tracer(name = nil, version = nil)
           name ||= ''
           version ||= ''
+          OpenTelemetry.logger.warn 'calling TracerProvider#tracer without providing a tracer name.' if name.empty?
           @mutex.synchronize { @registry[Key.new(name, version)] ||= Tracer.new(name, version, self) }
         end
 
@@ -52,14 +64,24 @@ module OpenTelemetry
         # After this is called all the newly created {Span}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 Tracer#shutdown multiple times.')
-              return
+              return Export::FAILURE
+            end
+
+            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
+            results = @span_processors.map do |processor|
+              remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
+              break [Export::TIMEOUT] if remaining_timeout&.zero?
+
+              processor.shutdown(timeout: remaining_timeout)
             end
-            @active_span_processor.shutdown(timeout: timeout)
             @stopped = true
+            results.max || Export::SUCCESS
           end
         end
 
@@ -78,7 +100,14 @@ module OpenTelemetry
           @mutex.synchronize do
             return Export::SUCCESS if @stopped
 
-            @active_span_processor.force_flush(timeout: timeout)
+            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
+            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.max || Export::SUCCESS
           end
         end
 
@@ -91,13 +120,53 @@ module OpenTelemetry
               OpenTelemetry.logger.warn('calling Tracer#add_span_processor after shutdown.')
               return
             end
-            @registered_span_processors << span_processor
-            @active_span_processor = if @registered_span_processors.size == 1
-                                       span_processor
-                                     else
-                                       MultiSpanProcessor.new(@registered_span_processors.dup)
-                                     end
+            @span_processors = @span_processors.dup.push(span_processor)
+          end
+        end
+
+        # @api private
+        def internal_create_span(name, kind, trace_id, parent_span_id, attributes, links, start_timestamp, parent_context, instrumentation_library) # rubocop:disable Metrics/MethodLength
+          trace_id ||= @id_generator.generate_trace_id
+          result = @sampler.should_sample?(trace_id: trace_id, parent_context: parent_context, links: links, name: name, kind: kind, attributes: attributes)
+          span_id = @id_generator.generate_span_id
+          if result.recording? && !@stopped
+            trace_flags = result.sampled? ? OpenTelemetry::Trace::TraceFlags::SAMPLED : OpenTelemetry::Trace::TraceFlags::DEFAULT
+            context = OpenTelemetry::Trace::SpanContext.new(trace_id: trace_id, span_id: span_id, trace_flags: trace_flags, tracestate: result.tracestate)
+            attributes = attributes&.merge(result.attributes) || result.attributes
+            Span.new(
+              context,
+              parent_context,
+              name,
+              kind,
+              parent_span_id,
+              @span_limits,
+              @span_processors,
+              attributes,
+              links,
+              start_timestamp,
+              @resource,
+              instrumentation_library
+            )
+          else
+            OpenTelemetry::Trace.non_recording_span(OpenTelemetry::Trace::SpanContext.new(trace_id: trace_id, span_id: span_id, tracestate: result.tracestate))
+          end
+        end
+
+        private
+
+        def sampler_from_environment(default_sampler) # rubocop:disable Metrics/CyclomaticComplexity
+          case ENV['OTEL_TRACES_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_TRACES_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_TRACES_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
       end
     end

data/lib/opentelemetry/sdk/version.rb

@@ -7,6 +7,6 @@
 module OpenTelemetry
   module SDK
     ## Current OpenTelemetry version
-    VERSION = '1.0.0.rc1'
+    VERSION = '1.0.0.rc2'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-sdk
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc1
+  version: 1.0.0.rc2
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-21 00:00:00.000000000 Z
+date: 2021-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.rc1
+        version: 1.0.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.rc1
+        version: 1.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: opentelemetry-common
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.19.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.19.0
 - !ruby/object:Gem::Dependency
   name: opentelemetry-instrumentation-base
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.18.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.18.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -192,25 +192,21 @@ files:
 - lib/opentelemetry-sdk.rb
 - lib/opentelemetry/sdk.rb
 - lib/opentelemetry/sdk/configurator.rb
+- lib/opentelemetry/sdk/forwarding_logger.rb
 - lib/opentelemetry/sdk/instrumentation_library.rb
 - lib/opentelemetry/sdk/internal.rb
 - lib/opentelemetry/sdk/resources.rb
 - lib/opentelemetry/sdk/resources/constants.rb
 - lib/opentelemetry/sdk/resources/resource.rb
 - lib/opentelemetry/sdk/trace.rb
-- lib/opentelemetry/sdk/trace/config.rb
-- lib/opentelemetry/sdk/trace/config/trace_config.rb
 - lib/opentelemetry/sdk/trace/event.rb
 - lib/opentelemetry/sdk/trace/export.rb
 - lib/opentelemetry/sdk/trace/export/batch_span_processor.rb
 - lib/opentelemetry/sdk/trace/export/console_span_exporter.rb
 - lib/opentelemetry/sdk/trace/export/in_memory_span_exporter.rb
 - lib/opentelemetry/sdk/trace/export/metrics_reporter.rb
-- lib/opentelemetry/sdk/trace/export/multi_span_exporter.rb
-- lib/opentelemetry/sdk/trace/export/noop_span_exporter.rb
 - lib/opentelemetry/sdk/trace/export/simple_span_processor.rb
-- lib/opentelemetry/sdk/trace/multi_span_processor.rb
-- lib/opentelemetry/sdk/trace/noop_span_processor.rb
+- lib/opentelemetry/sdk/trace/export/span_exporter.rb
 - lib/opentelemetry/sdk/trace/samplers.rb
 - lib/opentelemetry/sdk/trace/samplers/constant_sampler.rb
 - lib/opentelemetry/sdk/trace/samplers/decision.rb
@@ -219,6 +215,8 @@ files:
 - lib/opentelemetry/sdk/trace/samplers/trace_id_ratio_based.rb
 - lib/opentelemetry/sdk/trace/span.rb
 - lib/opentelemetry/sdk/trace/span_data.rb
+- lib/opentelemetry/sdk/trace/span_limits.rb
+- lib/opentelemetry/sdk/trace/span_processor.rb
 - lib/opentelemetry/sdk/trace/tracer.rb
 - lib/opentelemetry/sdk/trace/tracer_provider.rb
 - lib/opentelemetry/sdk/version.rb
@@ -226,10 +224,10 @@ homepage: https://github.com/open-telemetry/opentelemetry-ruby
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v1.0.0.rc1/file.CHANGELOG.html
+  changelog_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v1.0.0.rc2/file.CHANGELOG.html
   source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby/tree/main/sdk
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby/issues
-  documentation_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v1.0.0.rc1
+  documentation_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v1.0.0.rc2
 post_install_message: 
 rdoc_options: []
 require_paths:

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,85 +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 length of attribute value per {Span}.
-          attr_reader :max_attributes_length
-
-          # 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)), # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-                         max_attributes_count: Integer(ENV.fetch('OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT', 128)),
-                         max_attributes_length: ENV['OTEL_RUBY_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT'],
-                         max_events_count: Integer(ENV.fetch('OTEL_SPAN_EVENT_COUNT_LIMIT', 128)),
-                         max_links_count: Integer(ENV.fetch('OTEL_SPAN_LINK_COUNT_LIMIT', 128)),
-                         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_attributes_length must not be less than 32' unless max_attributes_length.nil? || Integer(max_attributes_length) >= 32
-            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_attributes_length = max_attributes_length.nil? ? nil : Integer(max_attributes_length)
-            @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_TRACES_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_TRACES_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_TRACES_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,76 +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 = OpenTelemetry::Common::Utilities.timeout_timestamp
-            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#force_flush} 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 force_flush(timeout: nil)
-            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
-            results = @span_exporters.map do |processor|
-              remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
-              return TIMEOUT if remaining_timeout&.zero?
-
-              processor.force_flush(timeout: remaining_timeout)
-            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 = OpenTelemetry::Common::Utilities.timeout_timestamp
-            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 = OpenTelemetry::Common::Utilities.timeout_timestamp
-          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 = OpenTelemetry::Common::Utilities.timeout_timestamp
-          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