instana 1.217.0 → 2.0.0

data/test/{tracing → trace}/custom_test.rb

@@ -9,11 +9,12 @@ class CustomTracingTest < Minitest::Test
 
     assert_equal false, ::Instana.tracer.tracing?
     # Start tracing
-    ::Instana.tracer.log_start_or_continue(:custom_trace, {:one => 1})
+    span = ::Instana.tracer.start_span(:custom_trace, attributes: {:one => 1})
     assert_equal true, ::Instana.tracer.tracing?
-    ::Instana.tracer.log_info({:info_logged => 1})
+    span.add_attributes({:info_logged => 1})
     # End tracing
-    ::Instana.tracer.log_end(:custom_trace, {:close_one => 1})
+    span.add_attributes({:close_one => 1})
+    span.finish
     assert_equal false, ::Instana.tracer.tracing?
 
     spans = ::Instana.processor.queued_spans
@@ -23,7 +24,7 @@ class CustomTracingTest < Minitest::Test
     assert_equal :sdk, first_span[:n]
 
     assert first_span[:ts].is_a?(Integer)
-    assert first_span[:ts] > 0
+    assert first_span[:ts].positive?
     assert first_span[:d].is_a?(Integer)
     assert first_span[:d].between?(0, 5)
 
@@ -50,21 +51,21 @@ class CustomTracingTest < Minitest::Test
 
     kvs = {}
     kvs[:on_entry_kv] = 1
-    kvs[:arguments] = [[1,2,3], "test_arg", :ok]
+    kvs[:arguments] = [[1, 2, 3], "test_arg", :ok]
     kvs[:return] = true
 
     # Start tracing
-    ::Instana.tracer.log_start_or_continue(:rack, :on_trace_start => 1)
+    span = ::Instana.tracer.start_span(:rack, attributes: {:on_trace_start => 1})
     assert_equal true, ::Instana.tracer.tracing?
 
     # Now the automagic
-    ::Instana.tracer.trace(:custom_span, kvs) do
+    ::Instana.tracer.in_span(:custom_span, attributes: kvs) do
       answer = 42 * 1
       active_span = ::Instana.tracer.current_span
       active_span.set_tag(:answer, answer)
 
       # And now nested automagic
-      ::Instana.tracer.trace(:custom_span2, kvs) do
+      ::Instana.tracer.in_span(:custom_span2, attributes: kvs) do
         was_here = 'stan'
         active_span = ::Instana.tracer.current_span
         active_span.set_tag(:was_here, was_here)
@@ -72,7 +73,8 @@ class CustomTracingTest < Minitest::Test
     end
 
     # End tracing
-    ::Instana.tracer.log_end(:rack, {:on_trace_end => 1})
+    span.add_attributes({:on_trace_end => 1})
+    span.finish
     assert_equal false, ::Instana.tracer.tracing?
 
     spans = ::Instana.processor.queued_spans
@@ -111,20 +113,23 @@ class CustomTracingTest < Minitest::Test
     assert_equal false, ::Instana.tracer.tracing?
 
     # Start tracing
-    ::Instana.tracer.log_start_or_continue(:rack, :on_trace_start => 1)
+    span1 = ::Instana.tracer.start_span(:rack, attributes: {:on_trace_start => 1})
     assert_equal true, ::Instana.tracer.tracing?
 
     kvs = {}
     kvs[:on_entry_kv] = 1
-    kvs[:arguments] = [[1,2,3], "test_arg", :ok]
+    kvs[:arguments] = [[1, 2, 3], "test_arg", :ok]
     kvs[:return] = true
 
-    ::Instana.tracer.log_entry(:custom_span, kvs)
-    ::Instana.tracer.log_info({:on_info_kv => 1})
-    ::Instana.tracer.log_exit(:custom_span, :on_exit_kv => 1)
+    span2 = ::Instana.tracer.start_span(:custom_span, attributes: kvs)
+    span2.set_tags({:on_info_kv => 1})
+    span2.set_tags({:on_exit_kv => 1})
+    span2.finish
 
     # End tracing
-    ::Instana.tracer.log_end(:rack, {:on_trace_end => 1})
+    span1.set_tags({:on_trace_end => 1})
+    span1.finish
+
     assert_equal false, ::Instana.tracer.tracing?
 
     spans = ::Instana.processor.queued_spans
@@ -134,7 +139,7 @@ class CustomTracingTest < Minitest::Test
     second_span = find_first_span_by_name(spans, :custom_span)
 
     assert first_span[:ts].is_a?(Integer)
-    assert first_span[:ts] > 0
+    assert first_span[:ts].positive?
     assert first_span[:d].is_a?(Integer)
     assert first_span[:d].between?(0, 5)
 
@@ -159,28 +164,30 @@ class CustomTracingTest < Minitest::Test
     assert_equal 1, second_span[:data][:sdk][:custom][:tags][:on_exit_kv]
   end
 
-  def test_custom_tracing_with_error
+  def test_custom_tracing_with_error # rubocop:disable Metrics/MethodLength
     clear_all!
     assert_equal false, ::Instana.tracer.tracing?
 
     # Start tracing
-    ::Instana.tracer.log_start_or_continue(:rack, :on_trace_start => 1)
+    span1 = ::Instana.tracer.start_span(:rack, attributes: {:on_trace_start => 1})
     assert_equal true, ::Instana.tracer.tracing?
 
     begin
       kvs = {}
       kvs[:on_entry_kv] = 1
-      kvs[:arguments] = [[1,2,3], "test_arg", :ok]
+      kvs[:arguments] = [[1, 2, 3], "test_arg", :ok]
       kvs[:return] = true
 
-      ::Instana.tracer.log_entry(:custom_span, kvs)
+      span2 = ::Instana.tracer.start_span(:custom_span, attributes: kvs)
       raise "custom tracing error.  This is only a test"
     rescue => e
-      ::Instana.tracer.log_error(e)
+      span2.record_exception(e)
     ensure
-      ::Instana.tracer.log_exit(:custom_span, :on_exit_kv => 1)
+      span2.set_tags(:on_exit_kv => 1)
+      span2.finish
     end
-    ::Instana.tracer.log_end(:rack, {:on_trace_end => 1})
+    span1.set_tags(:on_trace_end => 1)
+    span1.finish
     assert_equal false, ::Instana.tracer.tracing?
 
     spans = ::Instana.processor.queued_spans
@@ -190,7 +197,7 @@ class CustomTracingTest < Minitest::Test
     second_span = find_first_span_by_name(spans, :custom_span)
 
     assert first_span[:ts].is_a?(Integer)
-    assert first_span[:ts] > 0
+    assert first_span[:ts].positive?
     assert first_span[:d].is_a?(Integer)
     assert first_span[:d].between?(0, 5)
 
@@ -202,7 +209,7 @@ class CustomTracingTest < Minitest::Test
     assert_equal 1, first_span[:data][:on_trace_end]
 
     assert second_span[:ts].is_a?(Integer)
-    assert second_span[:ts] > 0
+    assert second_span[:ts].positive?
     assert second_span[:d].is_a?(Integer)
     assert second_span[:d].between?(0, 5)
 

data/test/{tracing → trace}/id_management_test.rb

@@ -1,5 +1,3 @@
-
-
 # (c) Copyright IBM Corp. 2021
 # (c) Copyright Instana Inc. 2016
 

data/test/{tracing → trace}/instrumented_logger_test.rb

@@ -11,7 +11,7 @@ class InstrumentedLoggerTest < Minitest::Test
   def test_log_warn_error
     subject = Instana::InstrumentedLogger.new('/dev/null')
 
-    Instana::Tracer.start_or_continue_trace(:test_logging) do
+    Instana::Tracer.in_span(:test_logging) do
       subject.warn('warn')
       subject.debug('test')
       subject.error('error')

data/test/{tracing → trace}/processor_test.rb

@@ -13,12 +13,12 @@ class ProcessorTest < Minitest::Test
     clear_all!
     subject = Instana::Processor.new
 
-    span_context = Instana::SpanContext.new('9', '8', 0)
-    span = Instana::Span.new(:rack, parent_ctx: span_context)
+    span_context = Instana::SpanContext.new(trace_id: '9', span_id: '8', level: 0)
+    span = Instana::Span.new(:rack, span_context)
     span2 = Instana::Span.new(:"net-http")
 
-    subject.add_span(span)
-    subject.add_span(span2)
+    subject.on_finish(span)
+    subject.on_finish(span2)
 
     spans = subject.queued_spans
     valid_span, = spans
@@ -29,7 +29,7 @@ class ProcessorTest < Minitest::Test
 
   def test_queued_spans_invalid_type
     subject = Instana::Processor.new
-    subject.add_span(false)
+    subject.on_finish(false)
 
     assert_equal [], subject.queued_spans
   end
@@ -39,7 +39,7 @@ class ProcessorTest < Minitest::Test
 
     subject = Instana::Processor.new
     span = Instana::Span.new(:rack)
-    subject.add_span(span)
+    subject.on_finish(span)
 
     was_invoked = false
 

data/test/{tracing → trace}/span_context_test.rb

@@ -5,17 +5,17 @@ require 'test_helper'
 
 class SpanContextTest < Minitest::Test
   def test_to_hash
-    subject = Instana::SpanContext.new('trace', 'span')
+    subject = Instana::SpanContext.new(trace_id: 'trace', span_id: 'span')
     assert_equal({trace_id: 'trace', span_id: 'span'}, subject.to_hash)
   end
 
   def test_invalid
-    subject = Instana::SpanContext.new(nil, nil)
+    subject = Instana::SpanContext.new(trace_id: nil, span_id: nil)
     refute subject.valid?
   end
 
   def test_flags_level_zero
-    subject = Instana::SpanContext.new('trace', 'span', 0, {external_state: 'cn=test'})
+    subject = Instana::SpanContext.new(trace_id: 'trace', span_id: 'span', level: 0, baggage: {external_state: 'cn=test'})
     assert_equal '00-000000000000000000000000000trace-000000000000span-00', subject.trace_parent_header
     assert_equal 'cn=test', subject.trace_state_header
   end

data/test/{tracing → trace}/span_test.rb

@@ -39,15 +39,15 @@ class SpanTest < Minitest::Test
   end
 
   def test_span_from_contetx
-    context = Instana::SpanContext.new('test', 'test', 0)
-    span = Instana::Span.new(:test, parent_ctx: context)
+    context = Instana::SpanContext.new(trace_id: 'test', span_id: 'test', level: 0)
+    span = Instana::Span.new(:test, context)
 
     assert_equal 'test', span.parent_id
     assert_equal 'test', span.trace_id
   end
 
   def test_span_from_contetx_invalid
-    context = Instana::SpanContext.new(nil, nil, 1)
+    context = Instana::SpanContext.new(trace_id: nil, span_id: nil, level: 1)
     span = Instana::Span.new(:test, parent_ctx: context)
 
     assert_nil span.parent_id
@@ -93,16 +93,16 @@ class SpanTest < Minitest::Test
     span = Instana::Span.new(:activerecord)
     span.set_tag(:activerecord, {})
 
-    span.add_error(StandardError.new('Test1'))
-    span.add_error(StandardError.new('Test2'))
+    span.record_exception(StandardError.new('Test1'))
+    span.record_exception(StandardError.new('Test2'))
 
     assert_equal 2, span[:ec]
     assert_equal 'Test2', span[:data][:activerecord][:error]
   end
 
-  def test_add_error_nil
+  def test_record_exception_nil
     span = Instana::Span.new(:activerecord)
-    span.add_error(nil)
+    span.record_exception(nil)
 
     assert_equal 1, span[:ec]
   end

data/test/{tracing → trace}/tracer_async_test.rb

@@ -8,7 +8,7 @@ class TracerAsyncTest < Minitest::Test
     clear_all!
 
     # Start tracing
-    ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
+    ::Instana.tracer.start_span(:rack, attributes: {:rack_start_kv => 1})
 
     # Start an asynchronous span
     span = ::Instana.tracer.log_async_entry(:my_async_op, { :entry_kv => 1})
@@ -54,26 +54,33 @@ class TracerAsyncTest < Minitest::Test
     clear_all!
 
     # Start tracing
-    ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
+    span = ::Instana.tracer.start_span(:rack, attributes: {:rack_start_kv => 1})
 
     t_context = ::Instana.tracer.context
     refute_nil t_context.trace_id
     refute_nil t_context.span_id
 
     Thread.new do
-      ::Instana.tracer.log_start_or_continue(:async_thread, { :async_start => 1 }, t_context)
-      ::Instana.tracer.log_entry(:sleepy_time, { :tired => 1 })
+      span1 = ::Instana::Trace.with_span(OpenTelemetry::Trace.non_recording_span(t_context)) do
+        ::Instana.tracer.start_span(:async_thread, attributes: { :async_start => 1 })
+      end
+      span2 = ::Instana::Trace.with_span(span1) do
+        ::Instana.tracer.start_span(:sleepy_time, attributes: { :tired => 1 })
+      end
+
       # Sleep beyond the end of this root trace
       sleep 0.5
-      ::Instana.tracer.log_exit(:sleepy_time, { :wake_up => 1})
-      ::Instana.tracer.log_end(:async_thread, { :async_end => 1 })
+      span2.set_tags({ :wake_up => 1})
+      span2.finish
+      span1.set_tags({:async_end => 1})
+      span1.finish
     end
-
     # Current span should still be rack
     assert_equal :rack, ::Instana.tracer.current_span.name
-
+    span.set_tags({:rack_end_kv => 1})
+    span.finish
     # End tracing
-    ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
+    # ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
 
     assert_equal false, ::Instana.tracer.tracing?
 
@@ -106,15 +113,14 @@ class TracerAsyncTest < Minitest::Test
     assert async_span2[:d]
     assert_equal 1, async_span2[:data][:sdk][:custom][:tags][:tired]
     assert_equal 1, async_span2[:data][:sdk][:custom][:tags][:wake_up]
-
     # Validate linkage
     # All spans have the same trace ID
-    assert rack_span[:t]==async_span1[:t] && async_span1[:t]==async_span2[:t]
+    assert rack_span[:t] == async_span1[:t] && async_span1[:t] == async_span2[:t]
 
     assert_equal async_span2[:p], async_span1[:s]
     assert_equal async_span1[:p], rack_span[:s]
 
-    assert rack_span[:t]  == rack_span[:s]
+    assert rack_span[:t] == rack_span[:s]
     assert async_span1[:t] != async_span1[:s]
     assert async_span2[:t] != async_span2[:s]
   end
@@ -123,15 +129,19 @@ class TracerAsyncTest < Minitest::Test
     clear_all!
 
     # Start tracing
-    ::Instana.tracer.log_start_or_continue(:rack, {:rack_start_kv => 1})
+    span = ::Instana.tracer.start_span(:rack, attributes: {:rack_start_kv => 1})
 
     # Start three asynchronous spans
-    span1 = ::Instana.tracer.log_async_entry(:my_async_op1, { :entry_kv => 1})
-    span2 = ::Instana.tracer.log_async_entry(:my_async_op2, { :entry_kv => 2})
-    span3 = ::Instana.tracer.log_async_entry(:my_async_op3, { :entry_kv => 3})
+    span1, span2, span3 = ::Instana::Trace.with_span(span) do
+      span1 = ::Instana.tracer.start_span(:my_async_op1, attributes: { :entry_kv => 1})
+      span2 = ::Instana.tracer.start_span(:my_async_op2, attributes: { :entry_kv => 2})
+      span3 = ::Instana.tracer.start_span(:my_async_op3, attributes: { :entry_kv => 3})
+      return span1, span2, span3
+    end
 
+    # Context awareness when using Opentelemetry is done through Opentelemetry::Context so the below test is invalid
     # Current span should still be rack
-    assert_equal :rack, ::Instana.tracer.current_span.name
+    # assert_equal :rack, ::Instana.tracer.current_span.name
 
     # Log info to the async spans (out of order)
     span2.set_tags({ :info_kv => 2 })
@@ -139,8 +149,8 @@ class TracerAsyncTest < Minitest::Test
     span3.set_tags({ :info_kv => 3 })
 
     # Log out of order errors to the async spans
-    span3.add_error(Exception.new("Async span 3"))
-    span2.add_error(Exception.new("Async span 3"))
+    span3.record_exception(Exception.new("Async span 3"))
+    span2.record_exception(Exception.new("Async span 3"))
 
     # End two out of order asynchronous spans
     span3.set_tags({ :exit_kv => 3 })
@@ -148,14 +158,16 @@ class TracerAsyncTest < Minitest::Test
     span2.set_tags({ :exit_kv => 2 })
     span2.close
 
+    # Context awareness when using Opentelemetry is done through Opentelemetry::Context so the below test is invalid
     # Current span should still be rack
-    assert_equal :rack, ::Instana.tracer.current_span.name
+    # assert_equal :rack, ::Instana.tracer.current_span.name
 
     # End tracing
-    ::Instana.tracer.log_end(:rack, {:rack_end_kv => 1})
+    span.set_tags({:rack_end_kv => 1})
+    span.finish
 
     # Log an error to and close out the remaining async span after the parent trace has finished
-    span1.add_error(Exception.new("Async span 1"))
+    span1.record_exception(Exception.new("Async span 1"))
     span1.set_tags({ :exit_kv => 1 })
     span1.close
 
@@ -201,12 +213,12 @@ class TracerAsyncTest < Minitest::Test
 
   def test_async_helpers
     clear_all!
-    ::Instana.tracer.log_start_or_continue(:rack)
+    ::Instana.tracer.start_span(:rack)
 
-    span = ::Instana.tracer.log_async_entry(:async, {})
-    ::Instana.tracer.log_async_info({a: 1}, span)
-    ::Instana.tracer.log_async_error(StandardError.new('Error'), span)
-    ::Instana.tracer.log_async_exit(nil, {}, span)
+    span1 = ::Instana.tracer.start_span(:async, attributes: {})
+    span1.set_tags({a: 1})
+    span1.record_exception(StandardError.new('Error'))
+    span1.finish
 
     spans = ::Instana.processor.queued_spans
     span, = spans
@@ -217,10 +229,11 @@ class TracerAsyncTest < Minitest::Test
 
   def test_async_helpers_tag_exit
     clear_all!
-    ::Instana.tracer.log_start_or_continue(:rack)
+    ::Instana.tracer.start_span(:rack)
 
-    span = ::Instana.tracer.log_async_entry(:async, {})
-    ::Instana.tracer.log_async_exit(nil, {a: 1}, span)
+    span1 = ::Instana.tracer.start_span(:async, attributes: {})
+    span1.set_tags({a: 1})
+    span1.finish
 
     spans = ::Instana.processor.queued_spans
     span, = spans

data/test/trace/tracer_provider_test.rb

@@ -0,0 +1,148 @@
+# (c) Copyright IBM Corp. 2025
+# (c) Copyright Instana Inc. 2025
+
+require 'test_helper'
+require 'instana/trace/tracer_provider'
+require 'instana/trace/export'
+
+class TracerProviderTest < Minitest::Test
+  def setup
+    @tracer_provider = Instana.tracer_provider
+  end
+
+  def test_tracer
+    # This tests the global tracer is the same as tracer from tracer_provider
+    assert_equal Instana.tracer, @tracer_provider.tracer("instana_tracer")
+  end
+
+  def test_shutdown_with_timeout
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    @tracer_provider.add_span_processor(DummyProcessor.new)
+    timeout = 10
+    result = @tracer_provider.shutdown(timeout: timeout)
+    assert_equal Instana::Trace::Export::SUCCESS, result
+    @span_processors = @tracer_provider.instance_variable_get(:@span_processors)
+    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
+    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
+    assert @tracer_provider.instance_variable_get(:@stopped)
+  end
+
+  def test_shutdown_without_timeout
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    @tracer_provider.add_span_processor(DummyProcessor.new)
+    # @tracer = @tracer_provider.tracer('test_shutdown_without_timeout')
+    result = @tracer_provider.shutdown
+    assert_equal Instana::Trace::Export::SUCCESS, result
+
+    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
+    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
+    assert @tracer_provider.instance_variable_get(:@stopped)
+  end
+
+  def test_shutdown_called_multiple_times
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    @tracer_provider.add_span_processor(DummyProcessor.new)
+    # @tracer = @tracer_provider.tracer('test_shutdown_called_multiple_times')
+
+    result1 = @tracer_provider.shutdown
+    result2 = @tracer_provider.shutdown
+
+    assert_equal Instana::Trace::Export::SUCCESS, result1
+    assert_equal Instana::Trace::Export::FAILURE, result2
+
+    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
+    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
+    assert @tracer_provider.instance_variable_get(:@stopped)
+  end
+
+  def test_shutdown_with_zero_timeout
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    @tracer_provider.add_span_processor(DummyProcessor.new)
+    # @tracer = @tracer_provider.tracer('test_shutdown_with_zero_timeout')
+    timeout = 0
+    result = @tracer_provider.shutdown(timeout: timeout)
+    assert_equal Instana::Trace::Export::TIMEOUT, result
+
+    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
+    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
+    assert @tracer_provider.instance_variable_get(:@stopped)
+  end
+
+  def test_force_flush_with_timeout
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    @tracer_provider.add_span_processor(DummyProcessor.new)
+    timeout = 10
+    result = @tracer_provider.force_flush(timeout: timeout)
+    assert_equal Instana::Trace::Export::SUCCESS, result
+    @span_processors = @tracer_provider.instance_variable_get(:@span_processors)
+    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
+    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
+  end
+
+  def test_force_flush_without_timeout
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    @tracer_provider.add_span_processor(DummyProcessor.new)
+    result = @tracer_provider.force_flush
+    assert_equal Instana::Trace::Export::SUCCESS, result
+
+    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
+    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
+  end
+
+  def test_force_flush_with_zero_timeout
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    @tracer_provider.add_span_processor(DummyProcessor.new)
+    timeout = 0
+    result = @tracer_provider.force_flush(timeout: timeout)
+    assert_equal Instana::Trace::Export::TIMEOUT, result
+
+    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
+    assert_equal [Instana::Trace::Export::SUCCESS], @tracer_provider.instance_variable_get(:@span_processors).map(&:shutdown)
+  end
+
+  def test_add_span_processor_after_shutdown
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    @tracer_provider.add_span_processor(DummyProcessor.new)
+    @tracer_provider.shutdown
+    result = @tracer_provider.add_span_processor(DummyProcessor.new)
+    assert_nil result
+    # No new span processor was added as tracer_provider is stopped
+    assert_equal 1, @tracer_provider.instance_variable_get(:@span_processors).length
+  end
+
+  def test_internal_start_span_untraced
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    Minitest::Mock.new
+    result = @tracer_provider.internal_start_span('test_span', 'kind', {}, [], Time.now, nil, @instrumentation_scope)
+    assert_instance_of(Instana::Span, result)
+    # Todo add proper testcase
+  end
+
+  def test_internal_start_span_traced
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    Minitest::Mock.new
+    result = @tracer_provider.internal_start_span('test_span', 'kind', {}, [], Time.now, nil, @instrumentation_scope)
+    assert_instance_of(Instana::Span, result)
+    # Todo add proper testcase
+  end
+
+  def test_internal_start_span_stopped
+    @tracer_provider = ::Instana::Trace::TracerProvider.new
+    Minitest::Mock.new
+    result = @tracer_provider.internal_start_span('test_span', 'kind', {}, [], Time.now, nil, @instrumentation_scope)
+    assert_instance_of(Instana::Span, result)
+    # Todo add proper testcase
+  end
+end
+
+class DummyProcessor
+  def initialize; end
+
+  def shutdown(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
+    Instana::Trace::Export::SUCCESS
+  end
+
+  def force_flush(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
+    Instana::Trace::Export::SUCCESS
+  end
+end