opentelemetry-sdk 1.0.0.rc1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5e0b06b7a072f462eeef975e4342a9e9800fb85794e2625f454d17eb20ef2be
-  data.tar.gz: a42a11084a981f147bdc5a3c5d21f1a4a1752d5a971819658573cb4964d43f49
+  metadata.gz: 0b0251902390864d89d8f00496f9ae36adcf3a52d1a84c574a73a107ccea70f0
+  data.tar.gz: ed15513dcd3d4decc53a0923db83c8e10d9b65a86247775c05d354212c1439c8
 SHA512:
-  metadata.gz: 670059ca8ef7d7aeba579c6b70a8217ac5e4fa879b39afee715b4ff1852e8643bf87581943b70d949480a728c531d20efc8ed42fa878f0a5291d55f31cc22607
-  data.tar.gz: 604feaa8d9952cce4a0eff45b743601b85ea2a5f7b03af316c5ae45c6df2fd57a2712d43d417a30a2df44b493fd6c8bc03f8924014a75d2fd29b9bfe513c7adf
+  metadata.gz: e3954c44377c4250f6dd2dcba2f88a781aa34acec642f19996014014c9d49ce3733846956043f09ce548ceee0362befa9ff9af660f894c39a446bdca5e0d7fb3
+  data.tar.gz: f8ddde936a93b87682a2f85a0d3a800ed0de25643bce04e420d01c8565c2ed33548dda6174c213d868aab82fe5398868144051690601d2b49015ea48bd999b9f

data/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Release History: opentelemetry-sdk
 
+### v1.0.1 / 2021-10-29
+
+* FIXED: Add unexpected error handlign in BSP and OTLP exporter (#995)
+
+### v1.0.0 / 2021-09-29
+
+* (No significant changes)
+
+### v1.0.0.rc3 / 2021-08-12
+
+* BREAKING CHANGE: Remove optional parent_context from in_span
+* BREAKING CHANGE: Replace Time.now with Process.clock_gettime
+* BREAKING CHANGE: Refactor Baggage to remove Noop*
+* BREAKING CHANGE: Remove unnecessary readers from SDK Tracer
+* BREAKING CHANGE: Total order constraint on span.status=
+* BREAKING CHANGE: Use auto-generated resource constants in sdk and resource_detectors
+* BREAKING CHANGE: Span limits env vars
+
+* ADDED: Add Tracer.non_recording_span to API
+* ADDED: Add unnamed tracer warning message
+* ADDED: Allow disabling of install messages
+* ADDED: Make API's NoopTextMapPropagator private
+* ADDED: Use auto-generated resource constants in sdk and resource_detectors
+* ADDED: Allow selecting multiple exporter
+* ADDED: Add explicit BSP export error
+* FIXED: Remove optional parent_context from in_span
+* FIXED: Replace Time.now with Process.clock_gettime
+* FIXED: Rename cloud.zone to cloud.availability_zone
+* FIXED: Improve attribute error messages
+* FIXED: Refactor Baggage to remove Noop*
+* FIXED: Support OTEL_SERVICE_NAME env var
+* FIXED: Remove unnecessary readers from SDK Tracer
+* FIXED: Total order constraint on span.status=
+* FIXED: Flakey tracer provider test
+* FIXED: Split lock in TracerProvider
+* FIXED: Span limits env vars
+* FIXED: Prune invalid links
+* DOCS: Update docs to rely more on environment variable configuration
+
+### 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/README.md

@@ -29,10 +29,33 @@ Then, configure the SDK according to your desired handling of telemetry data, an
 ```ruby
 require 'opentelemetry/sdk'
 
-# Configure the sdk with default export and context propagation formats
-# see SDK#configure for customizing the setup
+# Configure the sdk with default export and context propagation formats.
 OpenTelemetry::SDK.configure
 
+# Many configuration options may be set via the environment. To use them,
+# set the appropriate variable before calling configure. For example:
+#
+# ENV['OTEL_TRACES_EXPORTER'] = 'console'
+# ENV['OTEL_PROPAGATORS'] = 'ottrace'
+# OpenTelemetry::SDK.configure
+#
+# You may also configure the SDK programmatically, for advanced usage or to
+# enable auto-instrumentation. For example:
+#
+# OpenTelemetry::SDK.configure do |c|
+#   c.service_name = something_calculated_dynamically
+#   c.add_span_processor(
+#     OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+#       OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
+#     )
+#   )
+#
+#   c.use 'OpenTelemetry::Instrumentation::Net::HTTP'
+# end
+#
+# Note that the SimpleSpanExporter is not recommended for use in production.
+
+
 # To start a trace you need to get a Tracer from the TracerProvider
 tracer = OpenTelemetry.tracer_provider.tracer('my_app_or_gem', '0.1.0')
 

data/lib/opentelemetry/sdk/configurator.rb

@@ -9,13 +9,29 @@ module OpenTelemetry
     # The configurator provides defaults and facilitates configuring the
     # SDK for use.
     class Configurator # rubocop:disable Metrics/ClassLength
+      # @api private
+      class NoopTextMapPropagator
+        EMPTY_LIST = [].freeze
+        private_constant(:EMPTY_LIST)
+
+        def inject(carrier, context: Context.current, setter: Context::Propagation.text_map_setter); end
+
+        def extract(carrier, context: Context.current, getter: Context::Propagation.text_map_getter)
+          context
+        end
+
+        def fields
+          EMPTY_LIST
+        end
+      end
+
       USE_MODE_UNSPECIFIED = 0
       USE_MODE_ONE = 1
       USE_MODE_ALL = 2
 
       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 +47,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
@@ -51,7 +76,7 @@ module OpenTelemetry
       # @param [String] service_name The value to be used as the service name
       def service_name=(service_name)
         self.resource = OpenTelemetry::SDK::Resources::Resource.create(
-          OpenTelemetry::SDK::Resources::Constants::SERVICE_RESOURCE[:name] => service_name
+          OpenTelemetry::SemanticConventions::Resource::SERVICE_NAME => service_name
         )
       end
 
@@ -61,7 +86,7 @@ module OpenTelemetry
       # @param [String] service_version The value to be used as the service version
       def service_version=(service_version)
         self.resource = OpenTelemetry::SDK::Resources::Resource.create(
-          OpenTelemetry::SDK::Resources::Constants::SERVICE_RESOURCE[:version] => service_version
+          OpenTelemetry::SemanticConventions::Resource::SERVICE_VERSION => service_version
         )
       end
 
@@ -112,7 +137,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 +147,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)
@@ -141,21 +165,23 @@ module OpenTelemetry
       end
 
       def configure_span_processors
-        processors = @span_processors.empty? ? [wrapped_exporter_from_env].compact : @span_processors
+        processors = @span_processors.empty? ? wrapped_exporters_from_env.compact : @span_processors
         processors.each { |p| tracer_provider.add_span_processor(p) }
       end
 
-      def wrapped_exporter_from_env
-        exporter = ENV.fetch('OTEL_TRACES_EXPORTER', 'otlp')
-        case exporter
-        when 'none' then nil
-        when 'otlp' then fetch_exporter(exporter, 'OpenTelemetry::Exporter::OTLP::Exporter')
-        when 'jaeger' then fetch_exporter(exporter, 'OpenTelemetry::Exporter::Jaeger::CollectorExporter')
-        when 'zipkin' then fetch_exporter(exporter, 'OpenTelemetry::Exporter::Zipkin::Exporter')
-        when 'console' then Trace::Export::SimpleSpanProcessor.new(Trace::Export::ConsoleSpanExporter.new)
-        else
-          OpenTelemetry.logger.warn "The #{exporter} exporter is unknown and cannot be configured, spans will not be exported"
-          nil
+      def wrapped_exporters_from_env
+        exporters = ENV.fetch('OTEL_TRACES_EXPORTER', 'otlp')
+        exporters.split(',').map do |exporter|
+          case exporter.strip
+          when 'none' then nil
+          when 'otlp' then fetch_exporter(exporter, 'OpenTelemetry::Exporter::OTLP::Exporter')
+          when 'jaeger' then fetch_exporter(exporter, 'OpenTelemetry::Exporter::Jaeger::CollectorExporter')
+          when 'zipkin' then fetch_exporter(exporter, 'OpenTelemetry::Exporter::Zipkin::Exporter')
+          when 'console' then Trace::Export::SimpleSpanProcessor.new(Trace::Export::ConsoleSpanExporter.new)
+          else
+            OpenTelemetry.logger.warn "The #{exporter} exporter is unknown and cannot be configured, spans will not be exported"
+            nil
+          end
         end
       end
 
@@ -171,7 +197,7 @@ module OpenTelemetry
           when 'ottrace' then fetch_propagator(propagator, 'OpenTelemetry::Propagator::OTTrace')
           else
             OpenTelemetry.logger.warn "The #{propagator} propagator is unknown and cannot be configured"
-            Context::Propagation::NoopTextMapPropagator.new
+            NoopTextMapPropagator.new
           end
         end
         OpenTelemetry.propagation = Context::Propagation::CompositeTextMapPropagator.compose_propagators((@propagators || propagators).compact)

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,14 +31,14 @@ module OpenTelemetry
           end
 
           def default
-            @default ||= create(Constants::SERVICE_RESOURCE[:name] => 'unknown_service').merge(process).merge(telemetry_sdk)
+            @default ||= create(SemanticConventions::Resource::SERVICE_NAME => 'unknown_service').merge(process).merge(telemetry_sdk).merge(service_name_from_env)
           end
 
           def telemetry_sdk
             resource_attributes = {
-              Constants::TELEMETRY_SDK_RESOURCE[:name] => 'opentelemetry',
-              Constants::TELEMETRY_SDK_RESOURCE[:language] => 'ruby',
-              Constants::TELEMETRY_SDK_RESOURCE[:version] => OpenTelemetry::SDK::VERSION
+              SemanticConventions::Resource::TELEMETRY_SDK_NAME => 'opentelemetry',
+              SemanticConventions::Resource::TELEMETRY_SDK_LANGUAGE => 'ruby',
+              SemanticConventions::Resource::TELEMETRY_SDK_VERSION => OpenTelemetry::SDK::VERSION
             }
 
             resource_pairs = ENV['OTEL_RESOURCE_ATTRIBUTES']
@@ -55,15 +55,22 @@ module OpenTelemetry
 
           def process
             resource_attributes = {
-              Constants::PROCESS_RESOURCE[:pid] => Process.pid,
-              Constants::PROCESS_RESOURCE[:command] => $PROGRAM_NAME,
-              Constants::PROCESS_RUNTIME_RESOURCE[:name] => RUBY_ENGINE,
-              Constants::PROCESS_RUNTIME_RESOURCE[:version] => RUBY_VERSION,
-              Constants::PROCESS_RUNTIME_RESOURCE[:description] => RUBY_DESCRIPTION
+              SemanticConventions::Resource::PROCESS_PID => Process.pid,
+              SemanticConventions::Resource::PROCESS_COMMAND => $PROGRAM_NAME,
+              SemanticConventions::Resource::PROCESS_RUNTIME_NAME => RUBY_ENGINE,
+              SemanticConventions::Resource::PROCESS_RUNTIME_VERSION => RUBY_VERSION,
+              SemanticConventions::Resource::PROCESS_RUNTIME_DESCRIPTION => RUBY_DESCRIPTION
             }
 
             create(resource_attributes)
           end
+
+          private
+
+          def service_name_from_env
+            service_name = ENV['OTEL_SERVICE_NAME']
+            create(SemanticConventions::Resource::SERVICE_NAME => service_name) unless service_name.nil?
+          end
         end
 
         # @api private

data/lib/opentelemetry/sdk/resources.rb

@@ -13,4 +13,3 @@ module OpenTelemetry
 end
 
 require 'opentelemetry/sdk/resources/resource'
-require 'opentelemetry/sdk/resources/constants'

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

@@ -146,9 +146,9 @@ module OpenTelemetry
 
             thread&.join(timeout)
             force_flush(timeout: OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
-            @exporter.shutdown(timeout: OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
             dropped_spans = lock { spans.size }
             report_dropped_spans(dropped_spans, reason: 'terminating') if dropped_spans.positive?
+            @exporter.shutdown(timeout: OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
           end
 
           private
@@ -187,6 +187,10 @@ module OpenTelemetry
             result_code = @export_mutex.synchronize { @exporter.export(batch, timeout: timeout) }
             report_result(result_code, batch)
             result_code
+          rescue StandardError => e
+            report_result(FAILURE, batch)
+            @metrics_reporter.add_to_counter('otel.bsp.error', labels: { 'reason' => e.class.to_s })
+            FAILURE
           end
 
           def report_result(result_code, batch)
@@ -194,7 +198,7 @@ module OpenTelemetry
               @metrics_reporter.add_to_counter('otel.bsp.export.success')
               @metrics_reporter.add_to_counter('otel.bsp.exported_spans', increment: batch.size)
             else
-              OpenTelemetry.handle_error(message: "Unable to export #{batch.size} spans")
+              OpenTelemetry.handle_error(exception: ExportError.new("Unable to export #{batch.size} spans"))
               @metrics_reporter.add_to_counter('otel.bsp.export.failure')
               report_dropped_spans(batch.size, reason: 'export-failure')
             end

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/export.rb

@@ -10,6 +10,8 @@ module OpenTelemetry
       # The Export module contains the built-in exporters and span processors for the OpenTelemetry
       # reference implementation.
       module Export
+        ExportError = Class.new(OpenTelemetry::Error)
+
         # Result codes for the SpanExporter#export method and the SpanProcessor#force_flush and SpanProcessor#shutdown methods.
 
         # The operation finished successfully.
@@ -31,6 +33,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/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.link_attribute_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,54 @@ 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, link_attribute_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.span_context.valid? && link.attributes.size <= link_attribute_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|
+          valid_links = links.select { |link| link.span_context.valid? }
+          excess_link_count = valid_links.size - link_count_limit
+          valid_links.pop(excess_link_count) if excess_link_count.positive?
+          valid_links.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 - link_attribute_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
+          event_attribute_count_limit = @span_limits.event_attribute_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 <= event_attribute_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 - event_attribute_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 - event_attribute_count_limit
             excess.times { attrs.shift } if excess.positive?
             event = Event.new(event.name, attrs.freeze, event.timestamp)
           end