opentelemetry-sdk 0.17.0 → 1.0.0

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

@@ -101,7 +101,7 @@ module OpenTelemetry
           # @return [Integer] SUCCESS if no error occurred, FAILURE if a
           #   non-specific failure occurred, TIMEOUT if a timeout occurred.
           def force_flush(timeout: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
-            start_time = Time.now
+            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
             snapshot = lock do
               reset_on_fork if @keep_running
               spans.shift(spans.size)
@@ -137,7 +137,7 @@ module OpenTelemetry
           # @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
+            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
             thread = lock do
               @keep_running = false
               @condition.signal
@@ -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
@@ -194,7 +194,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,15 +10,16 @@ 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)
+        private_constant :DEFAULT_STATUS, :EMPTY_ATTRIBUTES
 
         # The following readers are intended for the use of SpanProcessors and
         # should not be considered part of the public interface for instrumentation.
@@ -70,7 +71,6 @@ module OpenTelemetry
         #
         # @return [self] returns itself
         def set_attribute(key, value)
-          super
           @mutex.synchronize do
             if @ended
               OpenTelemetry.logger.warn('Calling set_attribute on an ended Span.')
@@ -99,7 +99,6 @@ module OpenTelemetry
         #
         # @return [self] returns itself
         def add_attributes(attributes)
-          super
           @mutex.synchronize do
             if @ended
               OpenTelemetry.logger.warn('Calling add_attributes on an ended Span.')
@@ -132,8 +131,7 @@ module OpenTelemetry
         #
         # @return [self] returns itself
         def add_event(name, attributes: nil, timestamp: nil)
-          super
-          event = Event.new(name: name, attributes: truncate_attribute_values(attributes), timestamp: timestamp || Time.now)
+          event = Event.new(name, truncate_attribute_values(attributes), wall_clock(timestamp))
 
           @mutex.synchronize do
             if @ended
@@ -161,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)
@@ -169,21 +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)
-          super
+          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
@@ -199,7 +199,6 @@ module OpenTelemetry
         #
         # @return [void]
         def name=(new_name)
-          super
           @mutex.synchronize do
             if @ended
               OpenTelemetry.logger.warn('Calling name= on an ended Span.')
@@ -234,12 +233,12 @@ module OpenTelemetry
               OpenTelemetry.logger.warn('Calling finish on an ended Span.')
               return self
             end
-            @end_timestamp = end_timestamp || Time.now
+            @end_timestamp = wall_clock(end_timestamp)
             @attributes = validated_attributes(@attributes).freeze
             @events.freeze
             @ended = true
           end
-          @span_processor.on_finish(self)
+          @span_processors.each { |processor| processor.on_finish(self) }
           self
         end
 
@@ -277,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
@@ -292,13 +291,13 @@ module OpenTelemetry
           @total_recorded_events = 0
           @total_recorded_links = links&.size || 0
           @total_recorded_attributes = attributes&.size || 0
-          @start_timestamp = start_timestamp
+          @start_timestamp = wall_clock(start_timestamp)
           @end_timestamp = nil
           @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.
@@ -306,7 +305,7 @@ module OpenTelemetry
         private
 
         def validated_attributes(attrs)
-          return attrs if Internal.valid_attributes?(attrs)
+          return attrs if Internal.valid_attributes?(name, 'span', attrs)
 
           attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
         end
@@ -314,65 +313,73 @@ 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
         end
 
         def truncate_attribute_values(attrs)
-          return if attrs.nil?
+          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?(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
-          valid_attributes = Internal.valid_attributes?(event.attributes)
+          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(name: event.name, attributes: attrs, timestamp: event.timestamp)
+            event = Event.new(event.name, attrs.freeze, event.timestamp)
           end
           events << event
         end
+
+        def wall_clock(timestamp)
+          timestamp = (timestamp.to_r * 1_000_000_000).to_i unless timestamp.nil?
+          timestamp || Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+        end
       end
       # rubocop:enable Metrics/ClassLength
     end

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

@@ -10,24 +10,24 @@ module OpenTelemetry
     # implementation.
     module Trace
       # SpanData is a Struct containing {Span} data for export.
-      SpanData = Struct.new(:name,
-                            :kind,
-                            :status,
-                            :parent_span_id,
-                            :total_recorded_attributes,
-                            :total_recorded_events,
-                            :total_recorded_links,
-                            :start_timestamp,
-                            :end_timestamp,
-                            :attributes,
-                            :links,
-                            :events,
-                            :resource,
-                            :instrumentation_library,
-                            :span_id,
-                            :trace_id,
-                            :trace_flags,
-                            :tracestate) do
+      SpanData = Struct.new(:name,                      # String
+                            :kind,                      # Symbol: :internal, :producer, :consumer, :client, :server
+                            :status,                    # Status
+                            :parent_span_id,            # String (8 byte binary), may be OpenTelemetry::Trace::INVALID_SPAN_ID
+                            :total_recorded_attributes, # Integer
+                            :total_recorded_events,     # Integer
+                            :total_recorded_links,      # Integer
+                            :start_timestamp,           # Integer nanoseconds since Epoch
+                            :end_timestamp,             # Integer nanoseconds since Epoch
+                            :attributes,                # optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}
+                            :links,                     # optional Array[OpenTelemetry::Trace::Link]
+                            :events,                    # optional Array[Event]
+                            :resource,                  # OpenTelemetry::SDK::Resources::Resource
+                            :instrumentation_library,   # OpenTelemetry::SDK::InstrumentationLibrary
+                            :span_id,                   # String (8 byte binary)
+                            :trace_id,                  # String (16-byte binary)
+                            :trace_flags,               # Integer (8-bit byte of bit flags)
+                            :tracestate) do             # OpenTelemetry::Trace::Tracestate
                               # Returns the lowercase [hex encoded](https://tools.ietf.org/html/rfc4648#section-8) span ID.
                               #
                               # @return [String] A 16-hex-character lowercase string.
@@ -41,6 +41,13 @@ module OpenTelemetry
                               def hex_trace_id
                                 trace_id.unpack1('H*')
                               end
+
+                              # Returns the lowercase [hex encoded](https://tools.ietf.org/html/rfc4648#section-8) parent span ID.
+                              #
+                              # @return [String] A 16-hex-character lowercase string.
+                              def hex_parent_span_id
+                                parent_span_id.unpack1('H*')
+                              end
                             end
     end
   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 :event_attribute_count_limit
+
+        # The global default max number of attributes per {OpenTelemetry::Trace::Link}.
+        attr_reader :link_attribute_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)),
+                       event_attribute_count_limit: Integer(ENV.fetch('OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT', 128)),
+                       link_attribute_count_limit: Integer(ENV.fetch('OTEL_LINK_ATTRIBUTE_COUNT_LIMIT', 128)))
+          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, 'event_attribute_count_limit must be positive' unless event_attribute_count_limit.positive?
+          raise ArgumentError, 'link_attribute_count_limit must be positive' unless link_attribute_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
+          @event_attribute_count_limit = event_attribute_count_limit
+          @link_attribute_count_limit = link_attribute_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 || Time.now,
-              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